\h?SrSSKJr SSKJrJr SSKJr SSKJ r SSK J r J r SSK JrJrJrJr SSKJr SS KJr SS KJrJrJr SS KJrJrJrJrJr SS K J!r! SS K"J#r#J$r$ SSK%J&r& SSK'J(r(J)r)J*r* SSK+J,r,J-r- SSK.J/r/ SSK0J1r1J2r2 SSK3J4r4J5r5 SSK6J7r7J8r8 SSK9J:r: SSK;JJ?r? SSK@JArAJBrBJCrC SSKDJErE SSKFJGrG SSKHJIrJ SSKKJLrL SSKMJNrN SSKOJPrPJQrQJRrR SSKSJTrTJUrUJVrVJWrWJXrXJYrYJZrZJ[r[J\r\J]r]J^r^ SS K_J`r`JaraJbrbJcrcJdrdJere SS!KfJgrg SS"KhJiri SS#KjJkrkJlrlJmrm SS$KnJoro SS%KpJqrqJrrr SS&K;rsSS&KtrtSS'KuJvrv S(rw\l"S)S*\55rx\l"S+S,\x55ry\lS-5rzS.r{\lS/5r|S0r}S1r~\lSyS2j5r\lS35r\lS45r\lS55r\lS65r\lS75r\lS85r\lS95r\lS:5r\lS;5r\lS<5r\lS=5r\lS>5r\lS?5r\lS@5r\lSA5r\lSB5r\lSC5r\lSDSE.SFj5r\lSG5r\lSH5r\lSI5r\lSzSJj5r\lSK5r\lSzSLj5r\lSM5r\lSN5r\lSO5r\lSP5r\lSQ5r\lSR5r\lSS5r\lST5r\lSU5r\lSV5r\lSW5r\lSX5rSYrSZrS[rS\rS]rS^rS_rS`rSar\lSb5r\lSc5r\lSd5r\lSDSe.Sfj5r\lS{Sgj5r\lS|Shj5r\lS}Sij5r\lS~Skj5r\lS~Slj5r\lSSmj5r\lSn5r\lSo5r\lSjSp.Sqj5r\lSr5r\lSs5rI\lSt5r\l"SuSv\55r\lSw5rSxrg&)z8User-friendly public interface to polynomial functions. ) annotations)wrapsreducemul)Optional)Counter defaultdict)SExprAddTuple)Basic) _sympifyit)Factors factor_nc factor_terms) pure_complexevalffastlog_evalf_with_bounded_errorquad_to_mpmath) Derivative)Mul _keep_coeff)ilcm)IInteger equal_valued) RelationalEquality)ordered)DummySymbol)sympify_sympify)preorder_traversal bottom_up) BooleanAtom) polyoptions)construct_domain)FFQQZZ) DomainElement) matrix_fglm)groebner)Monomial) monomial_key)DMPDMFANP) OperationNotSupported DomainErrorCoercionFailedUnificationFailedGeneratorsNeededPolynomialErrorMultivariatePolynomialErrorExactQuotientFailedPolificationFailedComputationFailedGeneratorsError)basic_from_dict _sort_gens _unify_gens _dict_reorder_dict_from_expr_parallel_dict_from_expr)together)dup_isolate_real_roots_list)grouppublic filldedent)sympy_deprecation_warning)iterablesiftN) NoConvergencec0^[T5U4Sj5nU$)Nc:>[U5n[U[5(aT"X5$[U[5(a2UR"U/UR Q7SUR 06nT"X5$[U[5(a&UR"U/UR Q76nT"X5$[$![a^ UR(a[s$[UR5TR5nU"U5nU[La [SSSS9 Us$f=f)Ndomaina@ Mixing Poly with non-polynomial expressions in binary operations is deprecated. Either explicitly convert the non-Poly operand to a Poly with as_poly() or convert the Poly to an Expr with as_expr(). z1.6z)deprecated-poly-nonpoly-binary-operations)deprecated_since_versionactive_deprecations_target)r& isinstancePolyr from_exprgensrSr r< is_MatrixNotImplementedgetattras_expr__name__rM)fg expr_methodresultfuncs M/var/www/auris/envauris/lib/python3.13/site-packages/sympy/polys/polytools.pywrapper_polifyit..wrapperFs QK a  :  7 # # A88qxx8A:  4  "KK+AFF+&Az!! !)# ;;))%aiik4==A $Q/- 273^  ! sB22!DADD)r)rcres` rd _polifyitrgEs  4[""> Nc^\rSrSr%SrSrSrSrSrS\ S'S\ S 'SS jr \ S 5r \ S 5r\ S 5rSr\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5rU4Sjr\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r Sr!S r"SS!jr#S"r$S#r%S$r&S%r'S&r(S'r)SS(jr*S)r+S*r,S+r-S,r.S-r/S.r0S/r1SS0jr2SS1jr3SS2jr4SS3jr5SS4jr6S5r7S6r8S7r9S8r:S9r;SS:jrS=r?S>r@S?rASS@jrBSArCSBrDSCrESDrFSErGSFrHSGrISHrJSIrKSJrLSKrMSLrNSMrOSNrPSOrQSPrRSQrSSRrTSSSjrUSSTjrVSSUjrWSSVjrXSWrYSSXjrZSYr[SZr\S[r]S\r^SS]jr_S^r`SS_jraS`rbSarcSSbjrdSScjreSSdjrfSSejrgSSfjrhSgriShrjSSijrkSjrlSkrmSlrn\nroSSmjrpSnrqSSojrrSSpjrsSSqjrtSrruSsrvSStjrwSurxSSvjrySSwjrzSxr{Syr|Szr}S{r~SS|jrS}rS~rSrSrSrSrSrSSjrSrSrSrSrSSjrSSjrSSjrSrSSjrSSjrSSjrSSjrSSjrSSjrSSjrSrSrSrSrSrSrSSjrSrSSjr\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5r\ S5rSrSr\S5r\S5r\S5r\S5r\S5r\S5r\"S\5S5r\S5r\S5r\S5r\S5r\S5r\S5r\"S\5S5r\"S\5S5r\"S\5S5r\"S\5S5rSrSSjrSSjrSrSrU=r$)rWja 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 reprYTgn$@r4rlztuple[Expr, ...]rYc[R"X#5nSU;a [S5e[U[[ [ [45(aURX5$[U[S9(aA[U[5(aURX5$UR[U5U5$[U[!U5[LS9nUR"(aUR%X5$UR'X5$)z:Create a new polynomial instance out of something useful. orderz&'order' keyword is not implemented yet)exclude)evaluate)options build_optionsNotImplementedErrorrVr4r5r6r/_from_domain_elementrNstrdict _from_dict _from_listlistr%typeis_Poly _from_poly _from_exprclsrlrYargsopts rd__new__ Poly.__new__s##D/ c>%&NO O cCc=9 : :++C5 5 c3 '#t$$~~c//~~d3i55#S (<=C{{~~c//~~c//rhc[U[5(d[SU-5eUR[ U5S- :wa[SU<SU<35e[ R "U5nXlX#lU$)z:Construct :class:`Poly` instance from raw representation. z%invalid polynomial representation: %szinvalid arguments: z, ) rVr4r<levlenrrrlrY)rrlrYobjs rdnewPoly.newsg#s##!7#=? ? WWD A %!d"KL LmmC  rhc^[URR5/URQ76$N)rBrl to_sympy_dictrYselfs rdexpr Poly.exprs#txx557D$))DDrhc6UR4UR-$r)rrYrs rdr Poly.argss |dii''rhc6UR4UR-$rrkrs rd_hashable_contentPoly._hashable_contents{TYY&&rhcP[R"X#5nURX5$)(Construct a polynomial from a ``dict``. )rqrrrwr~s rd from_dictPoly.from_dict###D/~~c''rhcP[R"X#5nURX5$)(Construct a polynomial from a ``list``. )rqrrrxr~s rd from_listPoly.from_listrrhcP[R"X#5nURX5$)*Construct a polynomial from a polynomial. )rqrrr|r~s rd from_polyPoly.from_polyrrhcP[R"X#5nURX5$+Construct a polynomial from an expression. )rqrrr}r~s rdrXPoly.from_exprrrhc8URnU(d [S5e[U5S- nURnUc [ XS9upQO,UR 5HupgUR U5X'M UR"[R"XU5/UQ76$)rz0Cannot initialize from 'dict' without generatorsrr) rYr;rrSr+itemsconvertrr4r)rrlrrYlevelrSmonomcoeffs rdrwPoly._from_dictsxx"BD DD A  >*38KFC # #^^E2 !,wws}}S8@4@@rhcRURnU(d [S5e[U5S:wa [S5e[U5S- nURnUc [ XS9upQO[ [URU55nUR"[R"XU5/UQ76$)rz0Cannot initialize from 'list' without generatorsrz#'list' representation not supportedr) rYr;rr=rSr+rymaprrr4r)rrlrrYrrSs rdrxPoly._from_listsxx"BD D Y!^-57 7D A  >*38KFCs6>>3/0Cwws}}S8@4@@rhcXR:wa'UR"UR/URQ76nURnURnUR nU(aaURU:waQ[ UR5[ U5:wa URUR5U5$UR"U6nSU;aU(aURU5nU$USLaUR5nU$)rrST) __class__rrlrYfieldrSsetr}r]reorder set_domainto_field)rrlrrYrrSs rdr|Poly._from_poly%s -- ''#''-CHH-Cxx  CHH$388}D )~~ckkmS99kk4( s?v..(C d],,.C rhc>[X5upURX5$r)rFrw)rrlrs rdr}Poly._from_expr<s#3,~~c''rhcURnURn[U5S- nURU5/nUR"[ R "XU5/UQ76$Nr)rYrSrrrr4r)rrlrrYrSrs rdrtPoly._from_domain_elementBsQxxD A ~~c"#wws}}S8@4@@rhc >[TU]5$rsuper__hash__rrs rdr Poly.__hash__Lw!!rhc[5nURn[[U55H7nUR 5H nXC(dMXUR -n M5 M9 XR -$)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} )rrYrangermonoms free_symbolsfree_symbols_in_domain)rsymbolsrYirs rdrPoly.free_symbolsOsd*%yys4y!A88Aw333G'" 4444rhcURR[5p!UR(a#URHnX#R -nM U$UR (a%UR5HnX$R -nM U$)a  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} )rldomr is_Compositerris_EXcoeffs)rrSrgenrs rdrPoly.free_symbols_in_domainnso&((,,   ~~+++&  \\---'rhc URS$)z Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x rrYrs rdrPoly.gensyy|rhc"UR5$)aGet the ground domain of a :py:class:`~.Poly` Returns ======= :py:class:`~.Domain`: Ground domain of the :py:class:`~.Poly`. Examples ======== >>> from sympy import Poly, Symbol >>> x = Symbol('x') >>> p = Poly(x**2 + x) >>> p Poly(x**2 + x, x, domain='ZZ') >>> p.domain ZZ ) get_domainrs rdrS Poly.domains*  rhcUR"URRURRURR5/UR Q76$)z3Return zero polynomial with ``self``'s properties. )rrlzerorrrYrs rdr Poly.zeros;xx dhhllDHHLLANDIINNrhcUR"URRURRURR5/UR Q76$)z2Return one polynomial with ``self``'s properties. )rrlonerrrYrs rdrPoly.ones;xx TXX\\488<<@M499MMrhcJURU5up#pEU"U5U"U54$)aS 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)r_r`_perFGs rdunify Poly.unifys'2xx{ 1vs1v~rhc ^[U5nUR(dmURRR U5nURRUR URURR U54$[UR[5(GaB[UR[5(Ga"[URUR5nURRRURRU5[U5S- pTURU:wa[URR!5URU5upgURRU:wa4UVs/sH'oR#XRR5PM) nn[R$"['[)[+Xg555XT5n OURR#U5n URU:wa[URR!5URU5upURRU:wa4U Vs/sH'oR#XRR5PM) n n[R$"['[)[+X555XT5n O/URR#U5n O[SU<SU<35eUR,mXCS4U4Sjjn XMX4$![a [SU<SU<35ef=fs snfs snf)N Cannot unify  with rcz>Ub%USUX#S-S-nU(dURU5$TR"U/UQ76$rto_sympyrrlrrYremovers rdrPoly._unify..perH!GV}tQJK'88<<,,773&& &rh)r%r{rlr from_sympyr ground_newr9r:rVr4rDrYrrrEto_dictrrrvryzipr)r_r`g_coeffrYrrf_monomsf_coeffscrg_monomsg_coeffsrrrs @rdr Poly._unifysD AJyy J%%))..q1uuyy!%%0@0@0III aeeS ! !j&<&<qvvqvv.Duuyyquuyy$7TQvv~%2EEMMOQVVT&3"5599#CKL8a Auuyy 98HLMM$tC,C'D"EsPEEMM#&vv~%2EEMMOQVVT&3"5599#CKL8a Auuyy 98HLMM$tC,C'D"EsPEEMM#&#A$FG Gkk '~[" L'Q(JKK L M Ms%L.L;..ML8cUc URnUb9USUX#S-S-nU(d%URRRU5$URR "U/UQ76$)a 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') Nr)rYrlrrrr)r_rlrYrs rdrPoly.perse$ <66D  =4 #44Duuyy))#..{{s*T**rhc[R"URSU05nURURR UR 55$)z Set the ground domain of ``f``. rS)rqrrrYrrlrrS)r_rSrs rdrPoly.set_domain,s=##AFFXv,>?uuQUU]]3::.//rhc.URR$)z Get the ground domain of ``f``. )rlrr_s rdrPoly.get_domain1suuyyrhct[RRU5nUR[ U55$)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) )rqModulus preprocessrr,)r_moduluss rd set_modulusPoly.set_modulus5s+//,,W5||BwK((rhcUR5nUR(a[UR55$[ S5e)z Get the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, modulus=2).get_modulus() 2 z$not a polynomial over a Galois field)ris_FiniteFieldrcharacteristicr<)r_rSs rd get_modulusPoly.get_modulusFs8  60023 3!"HI IrhcXR;a4UR(aURX5$URX5$UR 5R X5$![a N+f=f)z)Internal implementation of :func:`subs`. )rY is_numberevalreplacer<r]subs)r_oldrs rd _eval_subsPoly._eval_subs[sb &&=}}vvc''99S..yy{))'sA## A0/A0cURR5up[UR5VVs/sHup4X1;dM UPM nnnUR X%S9$s snnf)z 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)rlro enumeraterYr)r_JrjrrYs rdro Poly.excludehsQ"+AFF"3B"3qz"3BuuSu$$Cs AAc Uc*UR(aURUp!O [S5eX:XdXR;aU$XR;aX R;arUR 5nUR (aX$R ;aB[UR5nX%URU5'URURUS9$[SU<SU<SU<35e)z 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') z(syntax supported only in univariate caserzCannot replace r in ) is_univariaterr<rYrrrryindexrrl)r_xy_ignorerrYs rdr Poly.replace{s 9uua1%>@@ 6Qff_H ;1FF?,,.C##q ';AFF|&'TZZ]#uuQUUu..1aKLLrhcBUR5R"U0UD6$)z-Match expression from Poly. See Basic.match())r]match)r_rkwargss rdr' Poly.matchsyy{  $1&11rhc [R"SU5nU(d[URUS9nO-[ UR5[ U5:wa [ S5e[ [[[URR5URU5655nUR[R"U[U5S- URR 5US9$)z 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') rz7generators list can differ only up to order of elementsrr)rqOptionsrCrYrr<rvryrrErlrrr4rrr)r_rYrrrls rdr Poly.reordersoob$'aff#.D [CI %!IK K4]155==?AFFDIJKLuuS]]3D A quuyyAuMMrhcvURSS9nURU5n0nUR5H,upV[USU5(a[ SU-5eXdXSS'M. UR USnUR "[R"U[U5S- URR5/UQ76$)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 %sr) as_dict _gen_to_levelranyr<rYrr4rrrlr)r_rrlrtermsrrrYs rdltrim Poly.ltrims&iiti$ OOC IIKLE5!9~~%&;a&?@@$%)  (vvabzuuS]]5#d)a-CKdKKrhc>[5nUH0nURRU5nURU5 M2 UR 5H(n[U5HupgXb;dM U(dM g M* g![a [ U<SU<S35ef=f)z 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  doesn't have as generatorFT)rrYr!add ValueErrorrArr)r_rYindicesrr!rrelts rd has_only_gensPoly.has_only_genss %C # S)  E"XXZE#E*# +  B%9:C@BB Bs A>>Bc[URS5(aURR5nO [US5eUR U5$)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)hasattrrlr@r7rr_rbs rdr@ Poly.to_rings? 155) $ $UU]]_F'95 5uuV}rhc[URS5(aURR5nO [US5eUR U5$)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)rArlrr7rrBs rdr Poly.to_field@ 155* % %UU^^%F':6 6uuV}rhc[URS5(aURR5nO [US5eUR U5$)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)rArlrHr7rrBs rdrH Poly.to_exact,rFrhc[URSS9XRR=(d SS9up#UR X0R US9$)a8 Recalculate the ground domain of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x, domain='QQ[y]') >>> f Poly(x**2 + 1, x, domain='QQ[y]') >>> f.retract() Poly(x**2 + 1, x, domain='ZZ') >>> f.retract(field=True) Poly(x**2 + 1, x, domain='QQ') TrN)r compositerS)r+r0rSrrrY)r_rrrls rdretract Poly.retractAsG($AII4I$888#8#8#@DB{{3s{33rhcUcSXp2nOURU5n[U5[U5p2[URS5(aURR X#U5nO [ US5eUR U5$)z1Take a continuous subsequence of terms of ``f``. rslice)r1intrArlrQr7r)r_r"mnrrbs rdrQ Poly.sliceYso 9!A!"A1vs1v1 155' " "UU[[q)F'73 3uuV}rhcURRUS9Vs/sH'o RRRU5PM) sn$s snf)z 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 rn)rlrrr)r_rnrs rdr Poly.coeffsis>(01uu||%|/HI/H! ""1%/HIIIs.A c4URRUS9$)z 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 rW)rlrr_rns rdr Poly.monomss$uu||%|((rhcURRUS9VVs/sH+up#X RRRU54PM- snn$s snnf)a  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 rW)rlr3rr)r_rnrSrs rdr3 Poly.termssE$89uu{{{7OP7OtqEEII&&q)*7OPPPs2AcURR5Vs/sH'oRRRU5PM) sn$s snf)z 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] )rl all_coeffsrr)r_rs rdr_Poly.all_coeffss<01uu/?/?/AB/A! ""1%/ABBBs.Ac6URR5$)z 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 )rl all_monomsrs rdrbPoly.all_monomss$uu!!rhcURR5VVs/sH+upXRRRU54PM- snn$s snnf)z 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)] )rl all_termsrr)r_rSrs rdrePoly.all_termssA89uu7HI7HtqEEII&&q)*7HIIIs2Ac0nUR5HIupVU"XV5n[U[5(aUupVOUnU(dM2XT;aXdU'M=[SU-5e UR"U/U=(d UR Q70UD6$)a 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)r3rVtupler<rrY)r_rcrYrr3rrrbs rdtermwise Poly.termwises$GGILE%'F&%((% uu%#(%L)9EACC&{{5>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x - 1).length() 3 )rr0rs rdlength Poly.lengths199;rhctU(aURRUS9$URRUS9$)z 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} rK)rlrr)r_r/rs rdr0 Poly.as_dicts4 55==d=+ +55&&D&1 1rhcxU(aURR5$URR5$)z%Switch to a ``list`` representation. )rlto_list to_sympy_list)r_r/s rdas_list Poly.as_list#s( 55==? "55&&( (rhcU(d UR$[U5S:Xaa[US[5(aIUSn[ UR 5nUR 5Hup4URU5nXAU'M [URR5/UQ76$![a [U<SU<S35ef=f)a  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 rrr7r8) rrrVrvryrYrr!r:rArBrlr)r_rYmappingrvaluer!s rdr] Poly.as_expr*s(66M t9>ja$771gGDFFFs +B((Ccj[U/UQ70UD6nUR(dgU$![a gf=f)a3Converts ``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)rWr{r<)rrYrpolys rdas_poly Poly.as_polyPs<  ,t,t,D<<   s %% 22c[URS5(aURR5nO [US5eUR U5$)z 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)rArlr~r7rrBs rdr~ Poly.liftjs? 155& ! !UUZZ\F'62 2uuV}rhc[URS5(aURR5upO [US5eXR U54$)z 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)rArlrr7rr_rrbs rdr Poly.deflatesF 155) $ $ IAv'95 5%%-rhcURRnUR(aU$UR(d[ SU-5e[ URS5(aURR US9nO [US5eU(aURUR-nOURUR-nUR"U/UQ76$)a7 Inject ground domain generators into ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x) >>> f.inject() Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ') >>> f.inject(front=True) Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ') z Cannot inject generators over %sinjectfront) rlr is_Numericalr{r8rArr7rrYr)r_rrrbrYs rdr Poly.injects$eeii   H@3FG G 155( # #UU\\\.F'84 4 ;;'D66CKK'DuuV#d##rhcURRnUR(d[SU-5e[ U5nUR SUU:XaUR USSpTO1UR U*SU:XaUR SU*SpTO [ S5eUR"U6n[URS5(aURRX%S9nO [US5eUR"U/UQ76$)a6 Eject selected generators into the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y) >>> f.eject(x) Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]') >>> f.eject(y) Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]') zCannot eject generators over %sNTFz'can only eject front or back generatorsejectr) rlrrr8rrYrsrrArr7r)r_rYrk_gensrrbs rdr Poly.ejects$eeii?#EF F I 66"1: 66!":t5 VVQBC[D 66#A2;5%9; ;jj$ 155' " "UU[[[2F'73 3uuV$e$$rhc[URS5(aURR5upO [US5eXR U54$)z 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)rArlrr7rrs rdrPoly.terms_gcdsG 155+ & &)IAv';7 7%%-rhc[URS5(aURRU5nO [US5eUR U5$)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)rArlrr7rr_rrbs rdrPoly.add_groundD 155, ' 'UU%%e,F'<8 8uuV}rhc[URS5(aURRU5nO [US5eUR U5$)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)rArlrr7rrs rdrPoly.sub_ground rrhc[URS5(aURRU5nO [US5eUR U5$)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)rArlrr7rrs rdrPoly.mul_ground"rrhc[URS5(aURRU5nO [US5eUR U5$)z 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)rArlrr7rrs rdrPoly.quo_ground7sD" 155, ' 'UU%%e,F'<8 8uuV}rhc[URS5(aURRU5nO [US5eUR U5$)aC 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)rArlrr7rrs rdrPoly.exquo_groundOsD& 155. ) )UU''.F'>: :uuV}rhc[URS5(aURR5nO [US5eUR U5$)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)rArlrr7rrBs rdrPoly.absis? 155% UUYY[F'51 1uuV}rhc[URS5(aURR5nO [US5eUR U5$)z 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)rArlrr7rrBs rdrPoly.neg~?" 155% UUYY[F'51 1uuV}rhc[U5nUR(dURU5$URU5up#pE[ UR S5(aUR U5nO [US5eU"U5$)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') r9)r%r{rrrArlr9r7r_r`rrrrrbs rdr9Poly.addh" AJyy<<? "xx{  155% UU1XF'51 16{rhc[U5nUR(dURU5$URU5up#pE[ UR S5(aUR U5nO [US5eU"U5$)a Subtract two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).sub(Poly(x - 2, x)) Poly(x**2 - x + 3, x, domain='ZZ') >>> Poly(x**2 + 1, x) - Poly(x - 2, x) Poly(x**2 - x + 3, x, domain='ZZ') sub)r%r{rrrArlrr7rs rdrPoly.subrrhc[U5nUR(dURU5$URU5up#pE[ UR S5(aUR U5nO [US5eU"U5$)a  Multiply two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') >>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') r)r%r{rrrArlrr7rs rdrPoly.mulrrhc[URS5(aURR5nO [US5eUR U5$)z 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)rArlrr7rrBs rdrPoly.sqrrrhc[U5n[URS5(aURRU5nO [ US5eUR U5$)a 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)rRrArlrr7rr_rTrbs rdrPoly.pow sJ" F 155% UUYYq\F'51 1uuV}rhcURU5up#pE[URS5(aURU5upgO [ US5eU"U5U"U54$)z 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)rrArlrr7)r_r`rrrrqrs rdr Poly.pdiv%sVxx{  155& ! !66!9DAq'62 21vs1v~rhcURU5up#pE[URS5(aURU5nO [ US5eU"U5$)a 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)rrArlrr7rs rdr Poly.prem<sJ<xx{  155& ! !VVAYF'62 26{rhcURU5up#pE[URS5(aURU5nO [ US5eU"U5$)aD 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)rrArlrr7rs rdr Poly.pquocsJ&xx{  155& ! !VVAYF'62 26{rhc.URU5up#pE[URS5(aURU5nO [US5eU"U5$![a3nUR UR 5UR 55eSnAff=f)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)rrArlrr>rr]r7)r_r`rrrrrbexcs rdr Poly.pexquos&xx{  155( # # 8!(84 46{ ' 8ggaiik199;77 8sA B!.BBcURU5up4pVSnU(aCUR(a2UR(d!UR5UR5peSn[ UR S5(aUR U5upO [US5eU(a"UR5U R5pXpU"U5U"U 54$![a Nf=f)a^ Polynomial division with remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x)) (Poly(1/2*x + 1, x, domain='QQ'), Poly(5, x, domain='QQ')) >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x), auto=False) (Poly(0, x, domain='ZZ'), Poly(x**2 + 1, x, domain='ZZ')) FTdiv) ris_Ringis_FieldrrArlrr7r@r9) r_r`autorrrrrNrrQRs rdrPoly.divs"!! CKK ::<qG 155% 558DAq'51 1  yy{AIIK111vs1v~ "  s$C C"!C"cURU5up4pVSnU(aCUR(a2UR(d!UR5UR5peSn[ UR S5(aUR U5nO [US5eU(aUR5nU"U5$![a Nf=f)a Computes the polynomial remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x)) Poly(5, x, domain='ZZ') >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x), auto=False) Poly(x**2 + 1, x, domain='ZZ') FTrem) rrrrrArlrr7r@r9) r_r`rrrrrrNrs rdrPoly.rem"!! CKK ::<qG 155% aA'51 1  IIK1v "  "B:: CCcURU5up4pVSnU(aCUR(a2UR(d!UR5UR5peSn[ UR S5(aUR U5nO [US5eU(aUR5nU"U5$![a Nf=f)a Computes polynomial quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x)) Poly(1/2*x + 1, x, domain='QQ') >>> Poly(x**2 - 1, x).quo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') FTquo) rrrrrArlrr7r@r9) r_r`rrrrrrNrs rdrPoly.quorrcURU5up4pVSnU(aCUR(a2UR(d!UR5UR5peSn[ UR S5(aUR U5nO [US5eU(aUR5nU"U5$![a3n U RUR5UR55eSn A ff=f![a NTf=f)aX Computes polynomial exact quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).exquo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') >>> Poly(x**2 + 1, x).exquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 FTexquoN) rrrrrArlrr>rr]r7r@r9) r_r`rrrrrrNrrs rdr Poly.exquos&!! CKK ::<qG 155' " " 8GGAJ(73 3  IIK1v ' 8ggaiik199;77 8"  s*=B;#C;; C8.C33C8; DDc@[U[5(aI[UR5nU*Us=::aU:aO O US:aX!-$U$[ SU<SU<SU<35eURR [ U55$![a [ SU-5ef=f)z3Returns level associated with the given generator. r-z <= gen < z expected, got z"a valid generator expected, got %s)rVrRrrYr<r!r%r:)r_rrls rdr1Poly._gen_to_level9s c3  [Fw#&&7!<'J%'-vs'<== @vv||GCL11 @%83>@@ @s #BBcURU5n[URS5(a3URRU5nUS:a[R nU$[ US5e)a  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 degreer)r1rArlrr NegativeInfinityr7)r_rrds rdr Poly.degreeMsX( OOC  155( # # QA1u&&H'84 4rhc[URS5(aURR5$[US5e)z Returns a list of degrees of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree_list() (2, 1) degree_list)rArlrr7rs rdrPoly.degree_listks5 155- ( (55$$& &'=9 9rhc[URS5(aURR5$[US5e)z Returns the total degree of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).total_degree() 2 >>> Poly(x + y**5, x, y).total_degree() 5 total_degree)rArlrr7rs rdrPoly.total_degree~s5 155. ) )55%%' ''>: :rhc[U[5(d[S[U5-5eXR;a(URR U5nURnO%[ UR5nURU4-n[URS5(a)URURRU5US9$[US5e)ab Returns the homogeneous polynomial of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(x**5 + 2*x**2*y**2 + 9*x*y**3) >>> f.homogenize(z) Poly(x**5 + 2*x**2*y**2*z + 9*x*y**3*z, x, y, z, domain='ZZ') z``Symbol`` expected, got %s homogenizerhomogeneous_order) rVr$ TypeErrorrzrYr!rrArlrrr7)r_srrYs rdrPoly.homogenizes,!V$$9DGCD D ; QA66DAFF A66QD=D 155, ' '55))!,458 8#A':;;rhc[URS5(aURR5$[US5e)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)rArlrr7rs rdrPoly.homogeneous_orders7( 155- . .55**, ,'+>? ?rhcUbURU5S$[URS5(aURR5nO [ US5eURR R U5$)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 rLC)rrArlrr7rr)r_rnrbs rdrPoly.LCsc  88E?1% % 155$  UUXXZF'40 0uuyy!!&))rhc[URS5(aURR5nO [US5eURRR U5$)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)rArlrr7rrrBs rdrPoly.TCsJ 155$  UUXXZF'40 0uuyy!!&))rhcx[URS5(aURU5S$[US5e)z Returns the last non-zero coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).EC() 3 rEC)rArlrr7rZs rdrPoly.ECs5 155( # #88E?2& &'40 0rhcZUR"[XR5R6$)a} 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 )nthr2rY exponents)r_rs rdcoeff_monomialPoly.coeff_monomials#Fuuhuff-7788rhcV[URS5(a^[U5[UR5:wa [ S5eURR "[ [[U556nO [US5eURRRU5$)a Returns the ``n``-th coefficient of ``f`` where ``N`` are the exponents of the generators in the term of interest. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x, y >>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2) 2 >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2) 2 >>> Poly(4*sqrt(x)*y) Poly(4*y*(sqrt(x)), y, sqrt(x), domain='ZZ') >>> _.nth(1, 1) 4 See Also ======== coeff_monomial rz,exponent of each generator must be specified) rArlrrYr:rryrrRr7rr)r_Nrbs rdrPoly.nth3sx2 155% 1vQVV$ !OPPUUYYSa[ 12F'51 1uuyy!!&))rhc[S5e)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.rs)r_r"rTrights rdr Poly.coeffUs" 01 1rhcR[URU5SUR5$)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 rr2rrYrZs rdLMPoly.LMas"$*AFF33rhcR[URU5SUR5$)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 rr rZs rdEMPoly.EMus"+QVV44rhc\URU5Sup#[X R5U4$)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) rr3r2rYr_rnrrs rdLTPoly.LTs,$wwu~a( vv&--rhc\URU5Sup#[X R5U4$)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) rrrs rdETPoly.ETs,wwu~b) vv&--rhc[URS5(aURR5nO [US5eURRR U5$)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)rArlrr7rrrBs rdr Poly.max_normsK 155* % %UU^^%F':6 6uuyy!!&))rhc[URS5(aURR5nO [US5eURRR U5$)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)rArlrr7rrrBs rdr Poly.l1_normJ 155) $ $UU]]_F'95 5uuyy!!&))rhc UnURRR(d[RU4$UR 5nUR (a$URRR5n[URS5(aURR5upEO [US5eURU5URU5p$U(aUR (dXB4$XBR54$)a+ Clear denominators, but keep the ground domain. Examples ======== >>> from sympy import Poly, S, QQ >>> from sympy.abc import x >>> f = Poly(x/2 + S(1)/3, x, domain=QQ) >>> f.clear_denoms() (6, Poly(3*x + 2, x, domain='QQ')) >>> f.clear_denoms(convert=True) (6, Poly(3*x + 2, x, domain='ZZ')) clear_denoms)rlrrr Onerhas_assoc_Ringget_ringrArr7rrr@)rrr_rrrbs rdrPoly.clear_denomss$ uuyy!!55!8Olln   %%))$$&C 155. ) )EE..0ME6'>: :<<&f qc008O))+% %rhc&UnURU5up4p!U"U5nU"U5nUR(aUR(dX!4$URSS9upRURSS9upaUR U5nUR U5nX!4$)a2 Clear denominators in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2/y + 1, x) >>> g = Poly(x**3 + y, x) >>> p, q = f.rat_clear_denoms(g) >>> p Poly(x**2 + y, x, domain='ZZ[y]') >>> q Poly(y*x**3 + y**2, x, domain='ZZ[y]') Tr)rrr!rr)rr`r_rrabs rdrat_clear_denomsPoly.rat_clear_denomss* !! F F !3!34K~~d~+~~d~+ LLO LLOt rhc$UnURSS5(a5URRR(aUR 5n[ URS5(aU(d(UR URRSS95$URnUHJn[U[5(aUupgOUSpvUR[U5URU55nML UR U5$[US5e)a2 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 integraterrS) getrlrrrrArr+rVrhrRr1r7)rspecsrr_rlspecrrSs rdr+Poly.integrate# s"  88FD ! !aeeii&7&7 A 155+ & &uuQUU__q_122%%CdE**!FC!1mmCFAOOC,@A 55: ';7 7rhcURSS5(d[U/UQ70UD6$[URS5(aU(d(UR URR SS95$URnUHJn[ U[5(aUupVOUSpeUR [U5URU55nML UR U5$[US5e)a 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') rpTdiffrr,) r-rrArlrr2rVrhrRr1r7)r_r.r(rlr/rrSs rdr2 Poly.diffK s"zz*d++a2%262 2 155& ! !uuQUUZZ!Z_--%%CdE**!FC!1hhs1vqs';< 55: '62 2rhcUnUc[U[5(a.UnUR5HupgURXg5nM U$[U[[ 45(aaUn[ U5[ UR5:a [S5e[URU5HupgURXg5nM U$SUp)OURU5n [URS5(d [US5eURRX)5n UR-XS9$![a U(d'[SU<SURR <35e[#U/5un unUR%5R'XR5n UR)U 5nU R+X+5nURRX)5n Nf=f)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') ztoo many values providedrrzCannot evaluate at rr)rVrvrrrhryrrYr:rr1rArlr7r9r8rr+runify_with_symbolsrrr) rr"r&rr_rvrrwvaluesrrba_domain new_domains rdr Poly.evals s>  9!T""")--/JCs*A#2At}--v;QVV,$%?@@"%afff"5JCs*A#6!1"Aquuf%%'62 2 *UUZZ%FuuVu&& *!1aeeii"PQQ 0! 5 #1\\^>>xP LL,&&q3A) *sD,,B/GGc$URU5$)a 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)r_r7s rd__call__ Poly.__call__ s(vvf~rhc.URU5up4pVU(a0UR(aUR5UR5pe[URS5(aUR U5upxO [ US5eU"U5U"U54$)ay 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)rrrrArlr?r7) r_r`rrrrrrhs rdr?Poly.half_gcdex sr&!! CKK::<q 155, ' '<<?DAq'<8 81vs1v~rhc>URU5up4pVU(a0UR(aUR5UR5pe[URS5(aUR U5upxn O [ US5eU"U5U"U5U"U 54$)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)rrrrArlrCr7) r_r`rrrrrrtr@s rdrC Poly.gcdex sy*!! CKK::<q 155' " "ggajGA!'73 31vs1vs1v%%rhcURU5up4pVU(a0UR(aUR5UR5pe[URS5(aUR U5nO [ US5eU"U5$)a2 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)rrrrArlrGr7)r_r`rrrrrrbs rdrG Poly.invert sf&!! CKK::<q 155( # #XXa[F'84 46{rhc[URS5(a%URR[U55nO [ US5eUR U5$)a 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)rArlrJrRr7rrs rdrJ Poly.revert3 sF6 155( # #UU\\#a&)F'84 4uuV}rhcURU5up#pE[URS5(aURU5nO [ US5e[ [ X655$)a 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)rrArlrMr7ryrrs rdrMPoly.subresultantsU sQ xx{  155/ * *__Q'F'?; ;C$%%rhc"URU5up4pV[URS5(a+U(aURXbS9upxOURU5nO [ US5eU(aU"USS9[ [ UW554$U"USS9$)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 includePRSrr5)rrArlrPr7ryr) r_r`rRrrrrrbrs rdrPPoly.resultantn s.xx{  155+ & &KKKA Q';7 7 q)4C +<= =6!$$rhc[URS5(aURR5nO [US5eUR USS9$)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 discriminantrr5)rArlrUr7rrBs rdrUPoly.discriminant sG 155. ) )UU'')F'>: :uuVAu&&rhcSSKJn U"X5$)aYCompute 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)r_r`rXs rdrXPoly.dispersionset sP 9Q""rhcSSKJn U"X5$)aGCompute 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)rYr\)r_r`r\s rdr\Poly.dispersion sP 6!rhcURU5up#pE[URS5(aURU5upgnO [ US5eU"U5U"U5U"U54$)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)rrArlr_r7) r_r`rrrrr@cffcfgs rdr_Poly.cofactors> s](xx{  155+ & &++a.KAC';7 71vs3xS))rhcURU5up#pE[URS5(aURU5nO [ US5eU"U5$)z 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)rrArlrdr7rs rdrdPoly.gcd[ Jxx{  155% UU1XF'51 16{rhcURU5up#pE[URS5(aURU5nO [ US5eU"U5$)z 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)rrArlrhr7rs rdrhPoly.lcmr rfrhcURRRU5n[URS5(aURR U5nO [ US5eUR U5$)z 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)rlrrrArkr7r)r_prbs rdrk Poly.trunc sY EEII  a  155' " "UU[[^F'73 3uuV}rhc$UnU(a5URRR(aUR5n[ URS5(aURR 5nO [ US5eURU5$)a* 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)rlrrrrAror7rrrr_rbs rdro Poly.monic sb"  AEEII%% A 155' " "UU[[]F'73 3uuV}rhc[URS5(aURR5nO [US5eURRR U5$)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)rArlrsr7rrrBs rdrs Poly.content rrhc[URS5(aURR5upO [US5eURRR U5UR U54$)z 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)rArlrvr7rrr)r_contrbs rdrvPoly.primitive s\ 155+ & &55??,LD&';7 7uuyy!!$'v66rhcURU5up#pE[URS5(aURU5nO [ US5eU"U5$)z 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)rrArlrzr7rs rdrz Poly.compose sJxx{  155) $ $YYq\F'95 56{rhc[URS5(aURR5nO [US5e[ [ UR U55$)z 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)rArlr}r7ryrrrBs rdr}Poly.decompose sH 155+ & &UU__&F';7 7Cv&''rhcVURURRU55$)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') See Also ======== shift_list: Analogous method for multivariate polynomials. )rrlshiftr_r&s rdr Poly.shift s$uuQUU[[^$$rhcVURURRU55$)a Efficiently compute Taylor shift ``f(X + A)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x*y, [x,y]).shift_list([1, 2]) == Poly((x+1)*(y+2), [x,y]) True See Also ======== shift: Analogous method for univariate polynomials. )rrl shift_listrs rdrPoly.shift_list' s"$uuQUU%%a())rhcFURU5up4URU5upSURU5upT[URS5(a1URRURUR5nO [ US5eUR U5$)z 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)rrArlrr7r)r_rlrPrrrbs rdrPoly.transform; sywwqzwwqzwwqz 155+ & &UU__QUUAEE2F';7 7uuV}rhc@UnU(a5URRR(aUR5n[ URS5(aURR 5nO [ US5e[[URU55$)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) rlrrrrArr7ryrrrps rdr Poly.sturmU sj"  AEEII%% A 155' " "UU[[]F'73 3Cv&''rhc[URS5(aURR5nO [US5eUVVs/sHup#UR U5U4PM snn$s snnf)a 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_list)rArlrr7r)r_rbr`rs rdr Poly.gff_listr sX 155* % %UU^^%F':6 6*01&$!q1 &111sA+c[URS5(aURR5nO [US5eUR U5$)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)rArlrr7r)r_rs rdr Poly.norm s>8 155& ! ! A'62 2uuQxrhc[URS5(aURR5upnO [US5eXR U5UR U54$)a 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)rArlrr7r)r_rr`rs rdr Poly.sqf_norm sQ0 155* % %eenn&GA!':6 6%%(AEE!H$$rhc[URS5(aURR5nO [US5eUR U5$)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)rArlrr7rrBs rdr Poly.sqf_part rFrhc2[URS5(aURRU5up#O [US5eURRR U5UVVs/sHupEUR U5U4PM snn4$s snnf)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_list)rArlrr7rrr)r_allrfactorsr`rs rdr Poly.sqf_list sv, 155* % %UU^^C0NE7':6 6uuyy!!%(W*MWTQAEE!Ha=W*MMM*Ms/Bc[URS5(aURRU5nO [US5eUVVs/sHup4UR U5U4PM snn$s snnf)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_include)rArlrr7r)r_rrr`rs rdrPoly.sqf_list_include s^4 155, - -ee,,S1G'+=> >*12'$!q1 '222s A,c[URS5(aURR5upO [US5eURRRU5UVVs/sHup4URU5U4PM snn4$![a@ UR 5S:XaUR 5/4s$[ RUS4/4s$f=fs snnf)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_listrr) rArlrr8rr]r r r7rrr)r_rrr`rs rdrPoly.factor_list s" 155- ( ( +!"!2!2!4w(=9 9uuyy!!%(W*MWTQAEE!Ha=W*MMM +88:?99;?*55Aq6(?*  ++NsB/C 0CCCc[URS5(aURR5nO [ US5eUVVs/sHup#UR U5U4PM snn$![a US4/s$f=fs snnf)a1 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_includer)rArlrr8r7r)r_rr`rs rdrPoly.factor_list_include< s" 155/ 0 0 %%335(+@A A*12'$!q1 '22  Ax 3sA, B,A>=A>c Ub'[R"U5nUS::a [S5eUb[R"U5nUb[R"U5n[URS5(aURR XX4XVS9nO [ US5eU(aMSnU(d[[X55$Sn Uup[[X55[[X554$SnU(d[[X55$Sn Uup[[X55[[X554$) aA 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)] r!'eps' must be a positive rational intervalsrepsinfsupfastsqfcbUup[R"U5[R"U54$rr-r)intervalrrDs rd_realPoly.intervals.._real s$ A A77rhcUuupup4[R"U5[[R"U5--[R"U5[[R"U5--4$rr-rr) rectangleuvrrDs rd_complex Poly.intervals.._complex sS!* A2;;q>)99 A2;;q>)99;;rhclUuupn[R"U5[R"U54U4$rr)rrrDrs rdrr s-$ QQ8!<@@rh) r-rr:rArlrr7ryr) r_rrrrrrrbrr real_part complex_parts rdrPoly.intervalsW s 4 ?**S/Cax !DEE ?**S/C ?**S/C 155+ & &UU__c%HF(;7 7  8C.// ; '- #IE-.S5P0QQ Q =C.// @ '- #IE-.S5P0QQ QrhcU(aUR(d [S5e[R"U5[R"U5p!Ub'[R"U5nUS::a [ S5eUb [ U5nOUcSn[ URS5(aURRXX4US9upxO [US5e[R"U5[R"U54$)z 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 supportedrrr refine_root)rstepsr) is_sqfr<r-rr:rRrArlrr7r) r_rrDrrr check_sqfr Ts rdrPoly.refine_root s QXX!"JK Kzz!}bjjm1 ?**S/Cax !DEE  JE [E 155- ( (55$$Qsd$KDAq'=9 9{{1~r{{1~--rhcSup4Ubv[U5nU[RLaSnOUUR5upVU(d[R "U5nO%[ [[R XV455Sp1Ubv[U5nU[RLaSnOUUR5upVU(d[R "U5nO%[ [[R XV455SpBU(aHU(aA[URS5(aURRXS9nO[US5eU(aUbU[R4nU(aUbU[R4n[URS5(aURRXS9nO [US5e[U5$)z Return the number of roots of ``f`` in ``[inf, sup]`` interval. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**4 - 4, x).count_roots(-3, 3) 2 >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I) 1 TTNFcount_real_rootsrrcount_complex_roots)r%r r as_real_imagr-rryrInfinityrArlrr7rrr)r_rrinf_realsup_realreimcounts rd count_rootsPoly.count_roots sc ( ?#,Ca((())+**S/C$(RZZ")B$CU ?#,Cajj ))+**S/C$(RZZ")B$CU quu011..3.@+A/ABBCOBGGnCOBGGnquu34411c1C+A/DEEu~rhcR[RRRXUS9$)as Get an indexed root of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4) >>> f.root(0) -1/2 >>> f.root(1) 2 >>> f.root(2) 2 >>> f.root(3) Traceback (most recent call last): ... IndexError: root index out of [-3, 2] range, got 3 >>> Poly(x**5 + x + 1).root(0) CRootOf(x**3 - x**2 + 1, 0) radicals)sympypolys rootoftoolsrootof)r_r!rs rdroot Poly.roots$6{{&&--a-JJrhc[RRRR XS9nU(aU$[ USS9$)a) Return a list of real roots with multiplicities. See :func:`real_roots` for more explanation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).real_roots() [CRootOf(x**3 + x + 1, 0)] rFmultiple)rrrCRootOf real_rootsrJ)r_rrrealss rdrPoly.real_roots$s<" ''//::1:P L/ /rhc[RRRR XS9nU(aU$[ USS9$)ai Return a list of real and complex roots with multiplicities. See :func:`all_roots` for more explanation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).all_roots() [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)] rFr)rrrr all_rootsrJ)r_rrrootss rdrPoly.all_roots<s<( ''//99!9O L/ /rhc ^ UR(a[SU-5eUR5S::a/$URR[ La*UR 5Vs/sHn[U5PM nnOURR[La]UR 5Vs/sHoDRPM nn[U6nUR 5Vs/sHn[XG-5PM nnOUR 5Vs/sH nURUS9R5PM" nn[R"U5 UVs/sHn[R"U6PM nnSSS5 [R$R&nU[R$lSSKJm [R,"XRUSUR5S-S 9n [/[1[2[5U U 4S jS 955n U[R$lU $s snfs snfs snfs snfs snf![ a# [#SURR-5ef=f!,(df  N=f![6ar [R,"XRUSUR5S -S 9n [/[1[2[5U U 4S jS 955n N![6a [7SU<SU<35ef=ff=f!U[R$lf=f)a Compute numerical approximations of roots of ``f``. Parameters ========== n ... the number of digits to calculate maxsteps ... the maximum number of iterations to do If the accuracy `n` cannot be reached in `maxsteps`, it will raise an exception. You need to rerun with higher maxsteps. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3).nroots(n=15) [-1.73205080756888, 1.73205080756888] >>> Poly(x**2 - 3).nroots(n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] z$Cannot compute numerical roots of %sr)rTz!Numerical domain expected, got %sN)signF )maxstepscleanuperror extraprecc>UR(aSOSUR[UR5T"UR54$Nrrimagrealrrrs rdPoly.nroots..s/!&&QaQVVVZ[\[a[aVb,crhkeyc>UR(aSOSUR[UR5T"UR54$rrrs rdrrs2aff!QVVSQRQWQW[Z^_`_e_eZf0grhz$convergence to root failed; try n < z or maxsteps > )is_multivariater=rrlrr.r_rRr-rrrrmpmathworkdpsmpcrr8mpdps$sympy.functions.elementary.complexesr polyrootsryrr%sortedrP) r_rTrrrrdenomsfacrrrs @rdnroots Poly.nrootsWs2  -6:< < 88:?I 5599?./lln=nUc%jnF=F UUYY"_+,<<>:>%gg>F:-C23,,.A.c%)n.FAF"#1!/kkAk&335!/ 1"'>DEfUfjj%0fFEF#iimm = $$V#5AHHJrMKE Wu"cdfgE FIIM W>:A1F '%&IEEII'&'''#"* " "((#5AHHJrMKS5&ghjk  "#x!"" " " FIIMsz&H-HH 'H  I H*H%,H*-A I+%H**-II I(+ K'6A KK*K##K''K**LcUR(a[SU-5e0nUR5SH2up#UR(dMUR 5upEX1U*U- 'M4 U$)z 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 %sr)rr=r is_linearr_)r_rfactorrr&r's rd ground_rootsPoly.ground_rootssp  -3a79 9+IF((*qbd ,  rhcbUR(a [S5e[U5nUR(aUS:a [ U5nO[ SU-5eUR n[S5nURURRX1-U- X455nURXC5$)a 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 polynomialrz&'n' must an integer and n >= 1, got %srD) rr=r% is_IntegerrRr:rr#rPrrXr)r_rTrr"rDrs rdnth_power_roots_polyPoly.nth_power_roots_polys,  -13 3 AJ <yyrhcUR(a [S5eUR5nUR(d0UR(dUR (d[ SU-5eURXR55$)aN Find roots of a square-free polynomial ``f`` from ``candidates``. Explanation =========== If ``f`` is a square-free polynomial and ``candidates`` is a superset of the roots of ``f``, then ``f.which_real_roots(candidates)`` returns a list containing exactly the set of roots of ``f``. The domain must be :ref:`ZZ`, :ref:`QQ`, or :ref:`QQ(a)` and``f`` must be univariate and square-free. The list ``candidates`` must be a superset of the real roots of ``f`` and ``f.which_real_roots(candidates)`` returns the set of real roots of ``f``. The output preserves the order of the order of ``candidates``. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> f = Poly(x**4 - 1) >>> f.which_real_roots([-1, 1, 0, -2, 2]) [-1, 1] >>> f.which_real_roots([-1, 1, 1, 1, 1]) [-1, 1] This method is useful as lifting to rational coefficients produced extraneous roots, which we can filter out with this method. >>> f = Poly(sqrt(2)*x**3 + x**2 - 1, x, extension=True) >>> f.lift() Poly(-2*x**6 + x**4 - 2*x**2 + 1, x, domain='QQ') >>> f.lift().real_roots() [-sqrt(2)/2, sqrt(2)/2] >>> f.which_real_roots(f.lift().real_roots()) [sqrt(2)/2] This procedure is already done internally when calling `.real_roots()` on a polynomial with algebraic coefficients. >>> f.real_roots() [sqrt(2)/2] See Also ======== same_root which_all_roots Must be a univariate polynomialz#root counting not supported over %s) rr=ris_ZZis_QQis_AlgebraicFieldrs _which_rootsr)r_ candidatesrs rdwhich_real_rootsPoly.which_real_rootsslj  -13 3lln SYY#*?*?%5;= =~~j--/::rhcxUR(a [S5eURXR55$)a Find roots of a square-free polynomial ``f`` from ``candidates``. Explanation =========== If ``f`` is a square-free polynomial and ``candidates`` is a superset of the roots of ``f``, then ``f.which_all_roots(candidates)`` returns a list containing exactly the set of roots of ``f``. The polynomial``f`` must be univariate and square-free. The list ``candidates`` must be a superset of the complex roots of ``f`` and ``f.which_all_roots(candidates)`` returns exactly the set of all complex roots of ``f``. The output preserves the order of the order of ``candidates``. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> f = Poly(x**4 - 1) >>> f.which_all_roots([-1, 1, -I, I, 0]) [-1, 1, -I, I] >>> f.which_all_roots([-1, 1, -I, I, I, I]) [-1, 1, -I, I] This method is useful as lifting to rational coefficients produced extraneous roots, which we can filter out with this method. >>> f = Poly(x**2 + I*x - 1, x, extension=True) >>> f.lift() Poly(x**4 - x**2 + 1, x, domain='ZZ') >>> f.lift().all_roots() [CRootOf(x**4 - x**2 + 1, 0), CRootOf(x**4 - x**2 + 1, 1), CRootOf(x**4 - x**2 + 1, 2), CRootOf(x**4 - x**2 + 1, 3)] >>> f.which_all_roots(f.lift().all_roots()) [CRootOf(x**4 - x**2 + 1, 0), CRootOf(x**4 - x**2 + 1, 2)] This procedure is already done internally when calling `.all_roots()` on a polynomial with algebraic coefficients, or polynomials with Gaussian domains. >>> f.all_roots() [CRootOf(x**4 - x**2 + 1, 0), CRootOf(x**4 - x**2 + 1, 2)] See Also ======== same_root which_real_roots r)rr=rr)r_rs rdwhich_all_rootsPoly.which_all_roots,s5r  -13 3~~j((*55rhcbSn[U5n[U5U:a{[UR55HHnU"U5R USU-S9n[ U5R S:dM7URU5 MJ US-n[U5U:aM{[UR55$)Nr)maxn)r rrykeysrr_precpop)r_r num_rootsprec root_countsrf_rs rdrPoly._which_rootsksj) +*+**,-djjAdFj3s8>>Q&OOA& . AID+*K$$&''rhc^ UR(a [S5eURR5nURR 5R U5nUS- n[SU- S05un n[U5nUS-US--m U 4Sjn U "U5U "U5pU RU R- S-U RU R- S--U:$)aL 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. See Also ======== which_real_roots which_all_roots r rr c*>[[UTS95$)Nr,)rr)r"rSs rdr Poly.same_root..s~&?Q&GHrh) rr=rlmignotte_sep_bound_squaredrS get_fieldrrrrr) r_r&r' dom_delta_sqdelta_sqeps_sqrrrTevABrSs @rd same_rootPoly.same_root{s>  -13 3uu779 88%%'00>A1V8Q+ 1a AJ !VA  H !ube1!#qvv&::VCCrhcpURU5up4pV[US5(aURXbS9nO [US5eU(d[UR(aUR 5nUuppUR U5nUR U 5n X- U"U 5U"U 54$[[XG55$)a Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x)) (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True) (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) cancel)include) rrAr9r7r!r"rrhr) r_r`r:rrrrrbcpcqrlrs rdr9 Poly.cancels"!! 1h  XXaX1F'84 4!!lln!LBAb!Bb!B5#a&#a&( (S)* *rhcUR(aUR[[4;a [ S5eUR (a&UR[:XaU[R 4$UR5nUR5up#UR[UR5U5R5U4$)a Turn any univariate polynomial over :ref:`QQ` or :ref:`ZZ` into a monic polynomial over :ref:`ZZ`, by scaling the roots as necessary. Explanation =========== This operation can be performed whether or not *f* is irreducible; when it is, this can be understood as determining an algebraic integer generating the same field as a root of *f*. Examples ======== >>> from sympy import Poly, S >>> from sympy.abc import x >>> f = Poly(x**2/2 + S(1)/4 * x + S(1)/8, x, domain='QQ') >>> f.make_monic_over_integers_by_scaling_roots() (Poly(x**2 + 2*x + 4, x, domain='ZZ'), 4) Returns ======= Pair ``(g, c)`` g is the polynomial c is the integer by which the roots had to be scaled z,Polynomial must be univariate over ZZ or QQ.) r rSr.r-r:is_monicrrorrrWrr@)r_fmrrs rd)make_monic_over_integers_by_scaling_roots.Poly.make_monic_over_integers_by_scaling_rootss<!((2r(":KL L ::!((b.bff9 B??$DA<<RVV a088:A= =rhc0SSKJnJnJnJn UR (a+UR (aUR[[4;a [S5eUUUUS.n[UR55n UR5n X:a[SU S35eU S:a [S5eU S:XaSS KJn U R S pO8U S :XaSS KJn UR$S pOUR'5unnX"XUS9upU(aU OU R)5nUU 4$)a& Compute the Galois group of this polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - 2) >>> G, _ = f.galois_group(by_name=True) >>> print(G) S4TransitiveSubgroups.D4 See Also ======== sympy.polys.numberfields.galoisgroups.galois_group r)_galois_group_degree_3_galois_group_degree_4_lookup(_galois_group_degree_5_lookup_ext_factor_galois_group_degree_6_lookupz>@DAqa JIDD!4!4!6#v rhc.URR$)z 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 )rlis_zerors rdr_ Poly.is_zero5s"uu}}rhc.URR$)z 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 )rlis_oners rdrb Poly.is_oneH"uu||rhc.URR$)z 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 )rlrrs rdr Poly.is_sqf[rdrhc.URR$)z 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 )rlr?rs rdr? Poly.is_monicns"uu~~rhc.URR$)z 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 )rl is_primitivers rdrjPoly.is_primitive"uu!!!rhc.URR$)z 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 )rl is_groundrs rdrnPoly.is_grounds&uurhc.URR$)z 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 )rlr rs rdr Poly.is_linears"uurhc.URR$)z 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 )rl is_quadraticrs rdrsPoly.is_quadraticrlrhc.URR$)z 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 )rl is_monomialrs rdrvPoly.is_monomials"uu   rhc.URR$)a 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 )rlis_homogeneousrs rdryPoly.is_homogeneouss,uu###rhc.URR$)z 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 )rlrQrs rdrQPoly.is_irreducibles"uu###rhc2[UR5S:H$)aK 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 rrrYrs rdr Poly.is_univariate *166{arhc2[UR5S:g$)aU 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 rr~rs rdrPoly.is_multivariate$rrhc.URR$)a3 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 )rl is_cyclotomicrs rdrPoly.is_cyclotomic;s,uu"""rhc"UR5$r)rrs rd__abs__ Poly.__abs__S uuwrhc"UR5$r)rrs rd__neg__ Poly.__neg__Vrrhc$URU5$rr9r_r`s rd__add__ Poly.__add__YuuQxrhc$URU5$rrrs rd__radd__ Poly.__radd__]rrhc$URU5$rrrs rd__sub__ Poly.__sub__arrhc$URU5$rrrs rd__rsub__ Poly.__rsub__errhc$URU5$rrrs rd__mul__ Poly.__mul__irrhc$URU5$rrrs rd__rmul__ Poly.__rmul__mrrhrTc^UR(aUS:aURU5$[$)Nr)rrr[)r_rTs rd__pow__ Poly.__pow__qs" <![[)_aff.>_15588AEEZ^8C__rhr+)returnrWNNr)FF)FTr)rFNT)rz#tuple[Expr, list[tuple[Poly, int]]])FNNNFFNNFFrr2T)FF)r^ __module__ __qualname____firstlineno____doc__ __slots__is_commutativer{ _op_priority__annotations__r classmethodrpropertyrrrrrrrXrwrxr|r}rtrrrrrSrrrrrrrr rrrorr'rr4r=r@rrHrNrQrrr3r_rbrerirlr0rsr]r{r~rrrrrrrrrrrr9rrrrrrrrrrrrr1rrrrrrrrrrrr r rrrrrr(r+r2_eval_derivativerr<r?rCrGrJrMrPrUrXr\r_rdrhrkrorsrvrzr}rrrrrrrrrrrrrrrrrrrr rrrrr6r9rAr\r_rbrr?rjrnr rsrvryrQr rrrrrgrrrrrrrr[rrrrrrrrrrrrrrr__static_attributes__ __classcell__rs@rdrWrWjs3j INGL H 0>  EE(('(( (( (( (( AA&AA*,(( AA"55<: !!,OONN83j+:0 )"J* *%&!MF2N4"LH D***40 J,)(Q(C "(J #=J 2&)$=L4* *#$J(%T ****04*0>>>04.%N8>%N#J#J(T@(5<:&;* &B> D&2#%J'*I#VI V*:...:**7*.(*%(*(4(:2.!F%>*N:3BN<36JRX#.J=~K:0006Ob6&P?;B=6~( 6Dp#+J%>N4l$$$$""$($""$!!$$$.$$$  ,  ,##.^$"%" ^$'%'^$'%'()"^$%, *``rhrWcl^\rSrSrSrSrU4Sjr\S5r\ "S\ 5S5r Sr S r S rU=r$) PurePolyiz)Class for representing pure polynomials. cUR4$)z$Allow SymPy to hash Poly instances. )rlrs rdrPurePoly._hashable_contents{rhc >[TU]5$rrrs rdrPurePoly.__hash__rrhcUR$)z 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} )rrs rdrPurePoly.free_symbolss&***rhrcXp2UR(d)URX2RUR5S9n[UR5[UR5:wagURRURR:wagURRRURRUR5nURU5nURU5nURUR:H$![[ [ 4a gf=f![a gf=fr) r{rrYrr<r8r9rrlrrr:r)rrr_r`rs rdrPurePoly.__eq__s1yy KK66!,,.KA qvv;#aff+ % 5599 ! eeiiooaeeii8 S!A S!Auu~$[.A  %  s$(DAD3D0/D03 E?Ec[XR5=(a$ URRURSS9$r)rVrrlrrs rdrPurePoly._strict_eqs+![[)JaeehhquuTh.JJrhc^[U5nUR(dkURRURURURR URRR U554$[UR5[UR5:wa[SU<SU<35e[UR[5(a[UR[5(d[SU<SU<35eURmURnURRRURRU5nURRU5nURRU5nX2S4U4SjjnX6XE4$![ a [SU<SU<35ef=f)Nrrcz>Ub%USUX#S-S-nU(dURU5$TR"U/UQ76$rrrs rdrPurePoly._unify..perrrh)r%r{rlrrrr9r:rrYrVr4rrr)r_r`rYrrrrrs @rdrPurePoly._unifysB AJyy Luuyy!%% !%%)):N:Nq:Q0RRR qvv;#aff+ %#A$FG G155#&&:aeeS+A+A#A$FG Gkkvveeiiooaeeii. EEMM#  EEMM#  '~5" L'Q(JKK Ls A)F//G r+)r^rrrrrrrrrr[rrrrrrs@rdrrsO3"++(().K  rhrcD[R"X5n[X5$r)rqrr_poly_from_expr)rrYrrs rdpoly_from_exprrs    +C 4 %%rhc"U[U5p[U[5(d [XU5eUR(aTUR R X5nURUlURUlURcSUl X14$UR(aUR5n[X5upAUR(d [XU5e[[[UR5565upVURnUc[XaS9uUlnO[[!UR"U55n[%[[XV555n[&R)XA5nURcSUl X14$)rTrF)r%rVrr?r{rr|rYrSrexpandrFryrrr+rrrvrWrw)rrorigrzrlrrrSs rdrr#s0wt}$ dE " " D11 ~~((399[[ 99 CIy {{}t)HC 88 D11#tCIIK012NF ZZF ~-f> Fc&++V45 tC'( )C ??3 $D yy 9rhcD[R"X5n[X5$)(Construct polynomials from expressions. )rqrr_parallel_poly_from_expr)exprsrYrrs rdparallel_poly_from_exprr Ks    +C #E //rhc [U5S:XaUup#[U[5(a[U[5(aURR X!5nURR X15nUR U5up#UR UlURUlURcSUlX#/U4$[U5/p//peSn[U5Hup[U 5n [U [5(aVU R(aURU5 O5URU5 UR(aU R5n OSnURU 5 M U(a [!XUS5eU(aUHnXR#5X'M [%X5upUR (d [!XUS5eSSKJn UR Hn [X5(dM[+S5e //p/n/nU Hjn[[-[UR/5565unnU R1U5 URU5 UR[U55 Ml URnUc[3XS9uUln O[[5UR6U 55n UHn URU SU 5 XSn M /n[-UU5HKunn[9[[-UU555n[R;UU5nURU5 MM URc[=U5UlUU4$) r r NTFr Piecewisez&Piecewise generators do not make senser)rrVrWrr|rrYrSrryrr%rr{appendrr?r]rG$sympy.functions.elementary.piecewiserr<rrextendr+rrrvrwbool)r rr_r`origs_exprs_polysfailedrrrepsrr coeffs_listlengthsrbr_rlrrrSrrzs rdr r Rs 5zQ a  :a#6#6 &&q.A &&q.A771:DAvvCHCJyy   63; ;5F FU#t} dE " "|| a  a ::;;=DF T$  UD99 Ax'')EH)4ID 88 UD99> XX a # #!"JK KrJJc4 #4566"&!s6{# ZZF ~"2;"H K3v00+>? +bq/*!"o  Ej*54FF+,-sC( T6  yyL #:rhc.[U5nX;aX U'U$)z7Add a new ``(key, value)`` pair to arguments ``dict``. )rv)rrrws rd _update_argsrs :D S Krhc x[USS9n[USS9RnUR(aUnUR5RnO5URnU(d"U(a[ U5up5O [ X5up5U(a'U(a[ R $[ R$U(d]UR(a+UWR;a[ UR55up5UWR;a[ R $OgUR(dV[UR5S:a=[[SU<S[[UR55<SU<S355eWRU5n[!U["5(a [%U5$[ R$)aP 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 Trrzj A symbolic generator of interest is required for a multivariate expression like func = z, e.g. degree(func, gen = z)) instead of degree(func, gen = z ). )r% is_Numberr{r]rr ZerorrYrrrrLnextr"rrVrRr)r_r gen_is_NumrlisNumrrbs rdrrs:6 $AT*44Jyy  %% %a(1%a- qvv2 2 22  99AFF*!!))+.DA aff 66M  YY3q~~.2 $wq~~./ $678 8 XXc]F(5576?M1;M;MMrhc[U5nUR(aUR5nUR(aSnO?UR(aU=(d URn[ X!5R 5n[U5$)aV Return the total_degree of ``f`` in the given variables. Examples ======== >>> from sympy import total_degree, Poly >>> from sympy.abc import x, y >>> total_degree(1) 0 >>> total_degree(x + x*y) 2 >>> total_degree(x + x*y, x) 1 If the expression is a Poly and no variables are given then the generators of the Poly will be used: >>> p = Poly(x + x*y, y) >>> total_degree(p) 1 To deal with the underlying expression of the Poly, convert it to an Expr: >>> total_degree(p.as_expr()) 2 This is done automatically if any variables are given: >>> total_degree(p, x) 1 See also ======== degree r)r%r{r]rrYrWrr)r_rYrlrvs rdrrs\P  Ayy IIK{{  99>166D !] ' ' ) 2;rhc[R"US/5 [U/UQ70UD6up4UR 5n[ [[U55$![an[ SSU5eSnAff=f)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) rrrN) rq allowed_flagsrr?r@rrhrr)r_rYrrrrdegreess rdrr*sq $ *71D1D1mmoG Wg& '' 7 q#667A A0 A++A0c[R"US/5 [U/UQ70UD6up4UR UR S9$![an[ SSU5eSnAff=f)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 rrrNrW)rqr&rr?r@rrnr_rYrrrrs rdrrEsi $ *.1D1D1 44cii4   .a--.sA A  AA c[R"US/5 [U/UQ70UD6up4UR UR S9nUR5$![an[ SSU5eSnAff=f)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 rr rNrW)rqr&rr?r@r rnr])r_rYrrrrrs rdr r ^st $ *.1D1D1 DDsyyD !E ==? .a--.r(c[R"US/5 [U/UQ70UD6up4UR UR S9upgXvR5-$![an[ SSU5eSnAff=f)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 rrrNrW)rqr&rr?r@rrnr])r_rYrrrrrrs rdrrxsy $ *.1D1D144cii4(LE   .a--.sA A4" A//A4c*[R"US/5 [X4/UQ70UD6uupEnUR U5upUR (d UR5U R54$X4$![an[ SSU5eSnAff=f)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) rrr N)rqr&r r?r@rrr] r_r`rYrrrrrrrs rdrrs $ *0-qfDtDtD  66!9DA 99yy{AIIK''t  03//0sA66 B B  Bc[R"US/5 [X4/UQ70UD6uupEnUR U5nUR (dUR5$U$![an[ SSU5eSnAff=f)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 rrr N)rqr&r r?r@rrr] r_r`rYrrrrrrs rdrrs $ *0-qfDtDtD  q A 99yy{ 03//0A## A?- A::A?c8[R"US/5 [X4/UQ70UD6uupEnUR U5nUR(dUR5$U$![an[ SSU5eSnAff=f![ a [ X5ef=f)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 rrr N) rqr&r r?r@rr>rr] r_r`rYrrrrrrs rdrrs" $ *0-qfDtDtD ( FF1I 99yy{ 03//0 (!!''(s"A$B$ B. A;;BBc[R"US/5 [X4/UQ70UD6uupEnUR U5nUR (dUR5$U$![an[ SSU5eSnAff=f)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 rrr N)rqr&r r?r@rrr]r3s rdrrs( $ *2-qfDtDtD   A 99yy{ 2!S112r1c<[R"USS/5 [X4/UQ70UD6uupEnUR XVR S9upUR(d UR5U R54$X4$![an[ SSU5eSnAff=f)z 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) rrrr Nr) rqr&r r?r@rrrr]r.s rdrrs" $ 12/-qfDtDtD  555 "DA 99yy{AIIK''t  /q#../sA?? B BBc[R"USS/5 [X4/UQ70UD6uupEnUR XVR S9nUR(dUR5$U$![an[ SSU5eSnAff=f)z 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 rrrr Nr6) rqr&r r?r@rrrr]r0s rdrr4" $ 12/-qfDtDtD  ahhA 99yy{ /q#../A,, B6 BBc[R"USS/5 [X4/UQ70UD6uupEnUR XVR S9nUR(dUR5$U$![an[ SSU5eSnAff=f)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 rrrr Nr6) rqr&r r?r@rrrr]r3s rdrrTr8r9c[R"USS/5 [X4/UQ70UD6uupEnUR XVR S9nUR(dUR5$U$![an[ SSU5eSnAff=f)a! 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 rrrr Nr6) rqr&r r?r@rrrr]r3s rdrrts( $ 121-qfDtDtD  !A 99yy{ 1C001r9c[R"USS/5 [X4/UQ70UD6uupEnUR XVRS9upUR(d U R5U R54$X4$![aun[ UR 5unupUR X5upURU 5URU 54sSnA$![a [SSU5ef=fSnAff=f)a0 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) rrNr?r r6) rqr&r r?r+r r?rrsr@rrr]) r_r`rYrrrrrrSr&r'rr@s rdr?r?s" $ 12 :-qfDtDtD  <<< )DA 99yy{AIIK''t  :)#))4 :$$Q*DA??1%vq'99 9# :#L!S9 9 : :s5A?? C> C9$C7!C9C>C66C99C>cF[R"USS/5 [X4/UQ70UD6uupEnUR XVRS9upn UR(d/U R5U R5U R54$XU 4$![an[ UR 5unupUR X5upn URU 5URU 5URU 54sSnA$![a [SSU5ef=fSnAff=f)a6 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) rrNrCr r6) rqr&r r?r+r rCrrsr@rrr])r_r`rYrrrrrrSr&r'rrDr@s rdrCrCs " $ 12 N-qfDtDtD ggahhg'GA! 99yy{AIIK44Qw N)#))4 Nll1(GA!??1%vq'96??1;MM M# 5#GQ4 4 5 Ns5B D D5D 1D:D DDD c[R"USS/5 [X4/UQ70UD6uupEnURXVRS9n UR(dU R5$U $![a`n[ UR 5unupUR URX55sSnA$![a [SSU5ef=fSnAff=f)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:`sympy.core.intfunc.mod_inverse` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.intfunc.mod_inverse rrNrGr r6) rqr&r r?r+r rrGrsr@rrr]) r_r`rYrrrrrrSr&r'r@s rdrGrGs@ $ 126-qfDtDtD  "A 99yy{ 6)#))4 6??6==#67 7" 6#Ha5 5 6 6s/A,, C6CB60C6CCCc.[R"US/5 [X4/UQ70UD6uupEnUR U5nUR (d UV s/sHoR5PM sn $U$![an[ SSU5eSnAff=fs sn f)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] rrMr N)rqr&r r?r@rMrr]) r_r`rYrrrrrrbrs rdrMrMs $ *9-qfDtDtD __Q F 99%+,V V,,  9C889 -sA3B3 B= B  BFrQc[R"US/5 [X4/UQ70UD6uupVnU(aUR XbS9upOUR U5n UR (dGU(a0U R5W V s/sHoR5PM sn 4$U R5$U(aU W 4$U $![an[ SSU5eSnAff=fs sn f)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 rrPr NrQ)rqr&r r?r@rPrr]) r_r`rRrYrrrrrrbrrs rdrPrP7s $ *5-qfDtDtD KKK9 Q 99 >>#1%=1aiik1%== =~~ 19   5 Q445&>sB>C> C CCc[R"US/5 [U/UQ70UD6up4UR 5nUR (dUR5$U$![an[ SSU5eSnAff=f)z Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 rrUrN)rqr&rr?r@rUrr]r_rYrrrrrbs rdrUrU\sy $ *81D1D1^^ F 99~~  83778A A:( A55A:c4[R"US/5 [X4/UQ70UD6uupEnUR U5upn UR(d/U R5U R5U R54$XU 4$![an[ UR 5unupUR X5upn URU 5URU 5URU 54sSnA$![a [SSU5ef=fSnAff=f)aa 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) rNr_r ) rqr&r r?r+r r_rrsr@rr])r_r`rYrrrrrrSr&r'r@r`ras rdr_r_zs& $ * R-qfDtDtD ++a.KAC 99yy{CKKM3;;=88s{ R)#))4 R **10KAC??1%vs';V__S=QQ Q# 9#KC8 8 9 Rs5B DD,C71D1D7DDDcv^^[U5nUU4SjnU"U5nUbU$[R"TS/5 [U/TQ70TD6upV[ U5S:a[ SU55(auUSnUSSVs/sHoU- R 5PM n n[ SU 55(a4Sn U Hn [XR5S5n M! [Xz- 5$U(d+UR(d[R$[!SUS 9$USUSSpTUH'n UR#U 5nUR$(dM' O UR(dUR'5$U$s snf![a7n U"U R5nUbUsSn A $[S [ U5U 5eSn A ff=f) 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 c>T(dT(d}[U5upU(d UR$UR(aLUSUSSp#UH,nURX45nUR U5(dM, O UR U5$gNrr)r+rrrdrbrseqrSnumbersrbnumberrrYs rdtry_non_polynomial_gcd(gcd_list..try_non_polynomial_gcdsyD.s3OF{{"$$")!*gabk%F#ZZ7F}}V,, & v..rhNrrc3^# UH#oR=(a URv M% g7fr is_algebraic is_irrational.0r<s rd gcd_list..$VRU3 0 0 FS5F5F FRU+-rc38# UHoRv M g7fr is_rationalrSfrcs rdrTrU2cs??crgcd_listr)r%rqr&r rrratsimprhas_numer_denomrr?r r@rr rrWrdrbr])rIrYrrLrbrrr&r<lstlcr\rrzs `` rdr_r_s #,C&$C (F   $ *?,S@4@4@  s8a > ?s7AE7>E2A E72E77 F8F3F8F33F8c>[US5(aUbU4U-n[U/UQ70UD6$Uc [S5e[R"US/5 [ X4/UQ70UD6uupEn[ [X45upxUR(atUR(acUR(aRUR(aAXx- R5n U R(a[XyR5S- 5$UR%U5n UR*(dU R-5$U $![a`n [U R 5un upxU R#U R%Xx55sSn A $![&a [)SSU 5ef=fSn A ff=f)z Compute GCD of ``f`` and ``g``. Examples ======== >>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 __iter__Nz2gcd() takes 2 arguments or a sequence of argumentsrrrdr )rAr_rrqr&r rr%rPrQr`rZrrar?r+r rrdrsr@rr] r_r`rYrrrrr&r'r\rrSrbs rdrdrds]q* =4$;D)D)D)) LMM $ *3-qfDtDtD 7QF# >>aoo!..Q__3--/C1//1!4455UU1XF 99~~  3)#))4 3??6::a#34 4" 3#E1c2 2 3 3s1B,D22 F<FE<6F<FFFcB^^[U5nS UU4SjjnU"U5nUbU$[R"TS/5 [U/TQ70TD6upV[ U5S:a[ SU55(alUSnUSSVs/sHoU- R 5PM n n[ SU 55(a+Sn U Hn [XR5S5n M! Xz-$U(d+UR(d[R$[SUS 9$US USSpTUHn URU 5nM UR(dUR!5$U$s snf![a7n U"U R5nUbUsSn A $[S[ U5U 5eSn A ff=f) 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 c >T(d{T(dt[U5upU(dURUR5$UR(a4USUSSp#UHnUR X45nM URU5$grG)r+rrrrhrHs rdtry_non_polynomial_lcm(lcm_list..try_non_polynomial_lcm=spD.s3OFvzz22$$")!*gabk%F#ZZ7F&v..rhNrrc3^# UH#oR=(a URv M% g7frrOrRs rdrTlcm_list..XrVrWrc38# UHoRv M g7frrYr[s rdrTrl[r]r^lcm_listrr)rzOptional[Expr])r%rqr&r rrr`rhrar?r r@rr r rWr])rIrYrrirbrrr&r<rbrcr\rrzs `` rdrnrn,s #,C $C (F   $ *?,S@4@4@  s8a > ?s7AEEAEE F'F=FFFc,[US5(aUbU4U-n[U/UQ70UD6$Uc [S5e[R"US/5 [ X4/UQ70UD6uupEn[ [X45upxUR(akUR(aZUR(aIUR(a8Xx- R5n U R(aXyR5S-$UR#U5n UR((dU R+5$U $![a`n [U R5un upxU R!U R#Xx55sSn A $![$a ['SSU 5ef=fSn A ff=f)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 reNz2lcm() takes 2 arguments or a sequence of argumentsrrrhr )rArnrrqr&r rr%rPrQr`rZrar?r+r rrhrsr@rr]rfs rdrhrhzsXq* =4$;D)D)D)) LMM $ *3-qfDtDtD 7QF# >>aoo!..Q__3--/C++-a000UU1XF 99~~  3)#))4 3??6::a#34 4" 3#E1c2 2 3 3s1B#D)) F3FE3-F3F  FFc ^^[U5n[U[5(a)[UU4SjURUR456$[U[ 5(a[ SU<35e[U[5(aUR(aU$TRSS5(a\UR"URVs/sHn[U/TQ70TD6PM sn6nTRS5 STS'[U/TQ70TD6$TRSS5n[R"TS/5 [!U/TQ70TD6upxUR5upUR&R((a_UR&R*(aUR-SS 9upUR/5upUR&R*(aU W -n O[0R2n [5[7UR8U 5V Vs/sH upX-PM snn 6n[;U S 5(a[0R2n US :XaU$U(a[=XUR?5-5$[=XR?5SS 9RA5up[=XU-SS 9$s snf!["an U R$sS n A $S n A ff=fs snn f) a 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 c3B># UHn[U/TQ70TD6v M g7fr)r)rSrrrYs rdrTterms_gcd..s N~!)A555~sz3Inequalities cannot be used with terms_gcd. Found: deepFrclearTrNr%r)rt)!r%rVr!lhsrhsr rr is_Atomr-rcrrr$rqr&rr?rrSrrrrvr r rrrYrrr] as_coeff_Mul)r_rYrrr&rrtrrrrdenomrr"rterms `` rdrrs5F 1:D!XNquu~NOO Az " "RSUVV a  !))  xxffAFFCFqy2T2T2FCD X,t,t,, HHWd #E $ *1D1D1 ;;=DA zz ::  ~~d~3HE;;= ::   UNE #affa.1.$!.1 2DE1 19K 5qyy{"2335))+U;HHJHE u1fE 22KD xx 2s* J6JJ?  J<& J71J<7J<c[R"USS/5 [U/UQ70UD6upEUR [ U55nUR(dUR5$U$![an[ SSU5eSnAff=f)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 rrrkrN) rqr&rr?r@rkr%rr])r_rlrYrrrrrbs rdrkrk#s $ 1211D1D1WWWQZ F 99~~  1C001sA)) B3 BBc[R"USS/5 [U/UQ70UD6up4UR UR S9nUR(dUR5$U$![an[ SSU5eSnAff=f)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 rrrorNr6) rqr&rr?r@rorrr]rBs rdroroAs $ 1211D1D1WW#((W #F 99~~  1C001sA(( B2 A??Bc[R"US/5 [U/UQ70UD6up4UR 5$![an[ SSU5eSnAff=f)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 rrsrN)rqr&rr?r@rsr*s rdrsrs_s` $ *31D1D1 99; 3 1c223s; A AAc[R"US/5 [U/UQ70UD6up4UR 5upgUR (dXgR54$Xg4$![an[ SSU5eSnAff=f)aI 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) rrvrN)rqr&rr?r@rvrr])r_rYrrrrrwrbs rdrvrvxs@ $ *51D1D1;;=LD 99^^%%%| 5 Q445sA"" A>, A99A>c[R"US/5 [X4/UQ70UD6uupEnUR U5nUR (dUR5$U$![an[ SSU5eSnAff=f)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 rrzr N)rqr&r r?r@rzrr]) r_r`rYrrrrrrbs rdrzrzs $ *3-qfDtDtD YYq\F 99~~  3 1c223r1c$[R"US/5 [U/UQ70UD6up4UR 5nUR (d UVs/sHowR5PM sn$U$![an[ SSU5eSnAff=fs snf)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] rr}rN)rqr&rr?r@r}rr]r_rYrrrrrbrs rdr}r}s $ *51D1D1[[]F 99%+,V V,,  5 Q445 -sA.B . B 8 BB c8[R"USS/5 [U/UQ70UD6up4UR UR S9nUR(d UVs/sHowR5PM sn$U$![an[ SSU5eSnAff=fs snf)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] rrrrNr6) rqr&rr?r@rrrr]rs rdrrs $ 1211D1D1WW#((W #F 99%+,V V,,  1C001 -sA8B8 B BBc4[R"US/5 [U/UQ70UD6up4UR 5nUR (d'UVVs/sHupxUR5U4PM snn$U$![an[ SSU5eSnAff=fs snnf)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 rrrN)rqr&rr?r@rrr]) r_rYrrrrrr`rs rdrrs@ $ *41D1D1jjlG 99-45WTQa W55 4 As334 6sA5B5 B? B  Bc[S5e)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialrr_rYrs rdgffr/s : ;;rhcd[R"US/5 [U/UQ70UD6up4UR 5upgnUV s/sHn [ U 5PM n n UR(d XR5UR54$XU4$![an[ SSU5eSnAff=fs sn f)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) rrrN) rqr&rr?r@rrrr]) r_rYrrrrrr`rsis_exprs rdrr5s& $ *41D1D1jjlGA!$% &AbgbkAF & 99yy{AIIK//!| 4 As334 'sBB- B* B%%B*c[R"US/5 [U/UQ70UD6up4UR 5nUR (dUR5$U$![an[ SSU5eSnAff=f)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 rrrN)rqr&rr?r@rrr]rBs rdrrYsx $ *41D1D1ZZ\F 99~~  4 As334rCcURR5n[U5[UR5[ UR 5U4$)zSort a list of polys.rlrqrrYrurS)rzrls rd_poly_sort_keyrws8 ((   C Hc$))nc$++&6 <.keysAID((""$CS3tyy>3t{{3CSI IrhcUupURR5n[U5[UR5U[ UR 5U4$rrrs rdrrsAID((""$CHc$))nc3t{{3CSI Irhr)r)rmethodrs rd_sorted_factorsr}s"  J  J ' ##rhcj[UVVs/sHupUR5U-PM snn6$s snnf)z*Multiply a list of ``(expr, exp)`` pairs. )rr])rr_rs rd_factors_productrs+ G4GDAaG4 554s/ c  ^[R/pC[R"U5Vs/sH&n[ US5(aUR 5OUPM( nnUGHMnUR (d%[U[5(a[U5(aX7-nM@UR(azUR[R:wa\URupUR (aU R (aX7-nMUR (aURX45 MOU[Rp[X5up[!XS-5n U "5upU [RLa^U R"(aX=U --nOEU R$(aURX45 O!URU [R45 U [RLaUR'U5 GMU R((a/UR'UVVs/sH unnUUU -4PM snn5 GM/nUHPunmUR+5R$(aURUTU -45 M=URUT45 MR UR[-U5U 45 GMP US:XaBUV Vs1sHupUiM snn V^s/sHm[3[4U4SjU55T4PM! nn[7[85nUHumnUT==U- ss'M U[;UR=554$s snfs snnf![.a)nURUR0U 45 SnAGMSnAff=fs snn fs snf)z.Helper function for :func:`_symbolic_factor`. _eval_factor_listNrc3<># UHupUT:XdM Uv M g7frr+)rSr_rrs rdrT(_symbolic_factor_list..s Awtq!q&ws  )r r r make_argsrArrrVr ris_PowbaseExp1rrrr\r is_positiver is_integerr]rr?rrrr rRryr)rrrrrrrargrrrzrrc_coeff_factorsr_rrrr$rs ` rd_symbolic_factor_listrsUUB7t$ &$A!(> : :ANN  A$  & ==ZT22|C7H7H LE  ZZCHH.ID~~#-- ~~{+QUU# ?%d0GD4'!12D#v FQUU">>S[(E''NNF=1OOVQUUO4aee|x(x@xtq!AcE x@A$DAqyy{..1S5z2 aV, %  0 7=>YZ+23741Q7353q3 Aw ABAF3 5 S B1 1  $rxxz" ""m &H A#" , NNCHHc? + + ,<45s/-L99 ML> 9M:&N M7M22M7c [U[5(aN[US5(aUR5$[ [ XSS9X5up4[ U[U55$[US5(a4UR"URVs/sHn[XQU5PM sn6$[US5(a,URUVs/sHn[XQU5PM sn5$U$s snfs snf)z%Helper function for :func:`_factor`. rfraction)rrre) rVr rArrrHrrrcr_symbolic_factorr)rrrrrrs rdrrs$ 4 ' '$$& &.x:/WY\e5"27";<< v  yyS#+Cf=STT z " "~~TRTc/&ATRSS TRs C( C-c[R"USS/5 [R"X5n[U5n[ U[ [ 45(Ga`[ U[ 5(aUSpeO[U5R5upV[XTU5upx[XdU5upU (aUR(d[SU-5eURSS05n X4H@n [U 5H.un upUR(aM[X5unnX4X'M0 MB [!X5n[!X5n UR"(dLUVVs/sHupUR%5U4PM nnnU VVs/sHupUR%5U4PM n nnXy- nUR(dUU4$UX4$[SU-5es snnfs snnf)z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrrza polynomial expected, got %srT)rqr&rrr%rVr rWrHrarrr<clonerr{rrrr])rrYrrrnumerryr;fpr<fq_optrrr_rrrs rd_generic_factor_listrs $ 12    +C 4=D$t %% dD ! !5#D>88:LE&u6:&u6: chh!"AD"HI Iyy(D)*xG&w/ 6Ayyy*13DAq"#GJ0 R ( R (yy/12rtq199;"rB2/12rtq199;"rB2xx"9 "= =DEE32s G9G cURSS5n[R"U/5 [R"X5nXES'[ [ U5XS5$)z4Helper function for :func:`sqf` and :func:`factor`. rT)r$rqr&rrrr%)rrYrrrrs rd_generic_factorr sJxx D)H $#    +C O GDM3 77rhc"^SSKJm S U4SjjnS U4SjjnSnUR5R(aVU"U5(aIUR 5nU"X5nU(aUSUSSUS4$U"X5nU(a SSUSUS4$g) a try to transform a polynomial to have rational coefficients try to find a transformation ``x = alpha*y`` ``f(x) = lc*alpha**n * g(y)`` where ``g`` is a polynomial with rational coefficients, ``lc`` the leading coefficient. If this fails, try ``x = y + beta`` ``f(x) = g(y)`` Returns ``None`` if ``g`` not found; ``(lc, alpha, None, g)`` in case of rescaling ``(None, None, beta, g)`` in case of translation Notes ===== Currently it transforms only polynomials without roots larger than 2. Examples ======== >>> from sympy import sqrt, Poly, simplify >>> from sympy.polys.polytools import to_rational_coeffs >>> from sympy.abc import x >>> p = Poly(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))}), x, domain='EX') >>> lc, r, _, g = to_rational_coeffs(p) >>> lc, r (7 + 5*sqrt(2), 2 - 2*sqrt(2)) >>> g Poly(x**3 + x**2 - 1/4*x - 1/4, x, domain='QQ') >>> r1 = simplify(1/r) >>> Poly(lc*r**3*(g.as_expr()).subs({x:x*r1}), x, domain='EX') == p True rsimplifyNc>[UR5S:XaURSR(dSU4$UR5nUR 5nU=(d UR 5nUR 5SSnUVs/sH nT "U5PM nn[U5S:aUS(aT "USUS- 5n/n[[U55H9nT "XHXhS---5nUR(d gURU5 M; T "SU- 5n URSn X-/n [SUS-5H!nU RXxS- XU- --5 M# [U 6n[U5nX9U4$gs snf)z 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``. rrNr) rrYrwrrror_rrZrr rW) r_f1rTrcrcoeffx rescale1_xcoeffs1r rescale_xr"rrs rd _try_rescale(to_rational_coeffs.._try_rescale;sr166{aq ':':7N HHJ TTV  288:$178v(6"8 v;?vbz!&*VBZ"78JG3v;'!&)JQ,?"?@))v& ( %Qz\2 FF1ITFq!a%AHHWU^AAJ67)GGa''%9s F c>[UR5S:XaURSR(dSU4$UR5nU=(d UR 5nUR 5SSnT "US5nUR (aPUR(d?[URSSS9upVUR"U6*U- nURU5nXx4$g)z 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``. rrNcURSL$rrY)zs rdr._try_translate..ms !--4/rhTbinary) rrYrwrror_is_AddrZrOrrcr) r_rrTrrratnonratalphaf2rs rd_try_translate*to_rational_coeffs.._try_translate]s166{aq ':':7N HHJ  288:$ VAY  88AMMqvv/>KCVVV_$Q&E%B9 rhcUR5nSnUHn[R"U5Hn[U5RnUR 5VVs/sHIupgUR (dMUR(dM+URS:dM=URPMK nnnU(dM[U5S:XaSn[U5S:dM g M U$s snnf)zC Return True if ``f`` is a sum with square roots but no other root Fr T) rr rrrrr is_RationalrminrR) rlrhas_sqr#r"r_r'wxrs rd_has_square_roots-to_rational_coeffs.._has_square_rootsssA]]1%AJ&&'(wwyByeaKK$&NN79ttqyRTTyBq6Q;!Fq6A: & BsC" 4C" C" C" rr r)sympy.simplify.simplifyrrrro)r_rrrrrrs @rdto_rational_coeffsrsL1 D,& ||~ 1! 4 4 WWY   Q41tQqT) )q%AT1Q41-- rhc SSKJn [XSS9nUR5n[ U5nU(dgUupgp[ U R 55n U(adU"U SU-Xt--5n U"SU- 5n /n U SSSH5nU RU"USRXU -055US45 M7 X4$U Sn /n U SSSH/nU RUSRXU- 05US45 M1 X4$)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 rrEXrMNr) rrrWrrrr]rr)rlr"rp1rTresrcrrDr`rrr1r&rs rd_torational_factor_listrs,1 a4 B A R C KB1!))+&G WQZ]14' ( ac] QA HHhqtyy!rT34ad; <  6M AJ QA HHadiiE +QqT2 3 6Mrhc[XUSS9$)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)]) rrrrs rdrrs e <>> from sympy import sqf >>> from sympy.abc import x >>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3 rr)rrs rdrrs 1D 77rhc[XUSS9$)z 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 rrrs rdrrs h ??rh)rsc^^[U5nU(aUU4Sjn[X5n0nUR[[5nUHAn[ U/TQ70TD6nUR (dUR(dM6X:wdM=XU'MC URU5$[UTTSS9$![a UR(d [U5s$ef=f)aR 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 cn>[U/TQ70TD6nUR(dUR(aU$U$)z; Factor, but avoid changing the expression when unable to. )r is_Mulr)rrrrYs rd _try_factorfactor.._try_factor:s0---CzzSZZ Krhr r) r%r(atomsrr r rrxreplacerr<rr) r_rsrYrrpartialsmuladdrlrs `` rdr r sH  A   a %c"A*T*T*C cjjjch! zz(##q$X>> Q<   s B((&CCc [US5(d[U5nURXX4XgS9$[ USS9up[ U R 5S:a[e[U5H!upU RR5X'M# Ub,U RRU5nUS::a [S5eUbU RRU5nUbU RRU5n[XRX#XEUS9n /n U HQuupnU RRU5U RRU5pU R!X4U45 MS U $![a /s$f=f) 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)] rerr-rMrrr)rrrrr)rArWr;rr rrYr=rrlrqrSrr:rIrr)rrrrrrrrrrrrzrrbrrDr;s rdrrWsd" 1j ! ! QA{{sD{RR,Qt<  sxx=1 - - 'GAxx'')EH( ?**$$S)Cax !DEE ?**$$S)C ?**$$S)C/zz#4A (OFQG::&&q)3::+>+>q+Aq MMA67+ , ) C  I s E&& E54E5c [U5n[U[5(d&URR(d [ S5eUR XX4XVS9$![ a [ SU-5ef=f)z Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import refine_root >>> from sympy.abc import x >>> refine_root(x**2 - 3, 1, 2, eps=1e-2) (19/11, 26/15) generator must be a Symbolz,Cannot refine a root of %s, not a polynomial)rrrr)rWrVr is_Symbolr<r;r)r_rrDrrrrrs rdrrsw @ G!T""155??"">? ? ==3$= TT @ :Q >@ @@s AAA2c[USS9n[U[5(d&URR(d [ S5eUR XS9$![ a [ SU-5ef=f)an Return the number of roots of ``f`` in ``[inf, sup]`` interval. If one of ``inf`` or ``sup`` is complex, it will return the number of roots in the complex rectangle with corners at ``inf`` and ``sup``. Examples ======== >>> from sympy import count_roots, I >>> from sympy.abc import x >>> count_roots(x**4 - 4, -3, 3) 2 >>> count_roots(x**4 - 4, 0, 1 + 3*I) 1 Fgreedyrz*Cannot count roots of %s, not a polynomialr)rWrVrrr<r;r)r_rrrs rdrrsp(P 5 !!T""155??"">? ? ==S= ** PJQNOOPs AAA/Tc[U[5(a:U(a0URR(d[URSS9nOUnOU(a [USS9nO [USS9n[U[5(d&UR R (d [S5eURXS9$![a [SU-5ef=f)a Returns the real and complex roots of ``f`` with multiplicities. Explanation =========== Finds all real and complex roots of a univariate polynomial with rational coefficients of any degree exactly. The roots are represented in the form given by :func:`~.rootof`. This is equivalent to using :func:`~.rootof` to find each of the indexed roots. Examples ======== >>> from sympy import all_roots >>> from sympy.abc import x, y >>> print(all_roots(x**3 + 1)) [-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2] Simple radical formulae are used in some cases but the cubic and quartic formulae are avoided. Instead most non-rational roots will be represented as :class:`~.ComplexRootOf`: >>> print(all_roots(x**3 + x + 1)) [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)] All roots of any polynomial with rational coefficients of any degree can be represented using :py:class:`~.ComplexRootOf`. The use of :py:class:`~.ComplexRootOf` bypasses limitations on the availability of radical formulae for quintic and higher degree polynomials _[1]: >>> p = x**5 - x - 1 >>> for r in all_roots(p): print(r) CRootOf(x**5 - x - 1, 0) CRootOf(x**5 - x - 1, 1) CRootOf(x**5 - x - 1, 2) CRootOf(x**5 - x - 1, 3) CRootOf(x**5 - x - 1, 4) >>> [r.evalf(3) for r in all_roots(p)] [1.17, -0.765 - 0.352*I, -0.765 + 0.352*I, 0.181 - 1.08*I, 0.181 + 1.08*I] Irrational algebraic coefficients are handled by :func:`all_roots` if `extension=True` is set. >>> from sympy import sqrt, expand >>> p = expand((x - sqrt(2))*(x - sqrt(3))) >>> print(p) x**2 - sqrt(3)*x - sqrt(2)*x + sqrt(6) >>> all_roots(p) Traceback (most recent call last): ... NotImplementedError: sorted roots not supported over EX >>> all_roots(p, extension=True) [sqrt(2), sqrt(3)] Algebraic coefficients can be complex as well. >>> from sympy import I >>> all_roots(x**2 - I, extension=True) [-sqrt(2)/2 - sqrt(2)*I/2, sqrt(2)/2 + sqrt(2)*I/2] >>> all_roots(x**2 - sqrt(2)*I, extension=True) [-2**(3/4)/2 - 2**(3/4)*I/2, 2**(3/4)/2 + 2**(3/4)*I/2] Transcendental coefficients cannot currently be handled by :func:`all_roots`. In the case of algebraic or transcendental coefficients :func:`~.ground_roots` might be able to find some roots by factorisation: >>> from sympy import ground_roots >>> ground_roots(p, x, extension=True) {sqrt(2): 1, sqrt(3): 1} If the coefficients are numeric then :func:`~.nroots` can be used to find all roots approximately: >>> from sympy import nroots >>> nroots(p, 5) [1.4142, 1.732] If the coefficients are symbolic then :func:`sympy.polys.polyroots.roots` or :func:`~.ground_roots` should be used instead: >>> from sympy import roots, ground_roots >>> p = x**2 - 3*x*y + 2*y**2 >>> roots(p, x) {y: 1, 2*y: 1} >>> ground_roots(p, x) {y: 1, 2*y: 1} Parameters ========== f : :class:`~.Expr` or :class:`~.Poly` A univariate polynomial with rational (or ``Float``) coefficients. multiple : ``bool`` (default ``True``). Whether to return a ``list`` of roots or a list of root/multiplicity pairs. radicals : ``bool`` (default ``True``) Use simple radical formulae rather than :py:class:`~.ComplexRootOf` for some irrational roots. extension: ``bool`` (default ``False``) Whether to construct an algebraic extension domain before computing the roots. Setting to ``True`` is necessary for finding roots of a polynomial with (irrational) algebraic coefficients but can be slow. Returns ======= A list of :class:`~.Expr` (usually :class:`~.ComplexRootOf`) representing the roots is returned with each root repeated according to its multiplicity as a root of ``f``. The roots are always uniquely ordered with real roots coming before complex roots. The real roots are in increasing order. Complex roots are ordered by increasing real part and then increasing imaginary part. If ``multiple=False`` is passed then a list of root/multiplicity pairs is returned instead. If ``radicals=False`` is passed then all roots will be represented as either rational numbers or :class:`~.ComplexRootOf`. See also ======== Poly.all_roots: The underlying :class:`Poly` method used by :func:`~.all_roots`. rootof: Compute a single numbered root of a univariate polynomial. real_roots: Compute all the real roots using :func:`~.rootof`. ground_roots: Compute some roots in the ground domain by factorisation. nroots: Compute all roots using approximate numerical techniques. sympy.polys.polyroots.roots: Compute symbolic expressions for roots using radical formulae. References ========== .. [1] https://en.wikipedia.org/wiki/Abel%E2%80%93Ruffini_theorem T extensionFrr1Cannot compute real roots of %s, not a polynomialrr) rVrWrSrrrrr<r;rr_rrrrs rdrrs`E a  !;!;40d+5)!T""155??"">? ? ;;; << E ?! CE EE B&B77Cc[U[5(a:U(a0URR(d[URSS9nOUnOU(a [USS9nO [USS9n[U[5(d&UR R (d [S5eURXS9$![a [SU-5ef=f)al Returns the real roots of ``f`` with multiplicities. Explanation =========== Finds all real roots of a univariate polynomial with rational coefficients of any degree exactly. The roots are represented in the form given by :func:`~.rootof`. This is equivalent to using :func:`~.rootof` or :func:`~.all_roots` and filtering out only the real roots. However if only the real roots are needed then :func:`real_roots` is more efficient than :func:`~.all_roots` because it computes only the real roots and avoids costly complex root isolation routines. Examples ======== >>> from sympy import real_roots >>> from sympy.abc import x, y >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4, multiple=False) [(-1/2, 1), (2, 2)] Real roots of any polynomial with rational coefficients of any degree can be represented using :py:class:`~.ComplexRootOf`: >>> p = x**9 + 2*x + 2 >>> print(real_roots(p)) [CRootOf(x**9 + 2*x + 2, 0)] >>> [r.evalf(3) for r in real_roots(p)] [-0.865] All rational roots will be returned as rational numbers. Roots of some simple factors will be expressed using radical or other formulae (unless ``radicals=False`` is passed). All other roots will be expressed as :class:`~.ComplexRootOf`. >>> p = (x + 7)*(x**2 - 2)*(x**3 + x + 1) >>> print(real_roots(p)) [-7, -sqrt(2), CRootOf(x**3 + x + 1, 0), sqrt(2)] >>> print(real_roots(p, radicals=False)) [-7, CRootOf(x**2 - 2, 0), CRootOf(x**3 + x + 1, 0), CRootOf(x**2 - 2, 1)] All returned root expressions will numerically evaluate to real numbers with no imaginary part. This is in contrast to the expressions generated by the cubic or quartic formulae as used by :func:`~.roots` which suffer from casus irreducibilis [1]_: >>> from sympy import roots >>> p = 2*x**3 - 9*x**2 - 6*x + 3 >>> [r.evalf(5) for r in roots(p, multiple=True)] [5.0365 - 0.e-11*I, 0.33984 + 0.e-13*I, -0.87636 + 0.e-10*I] >>> [r.evalf(5) for r in real_roots(p, x)] [-0.87636, 0.33984, 5.0365] >>> [r.is_real for r in roots(p, multiple=True)] [None, None, None] >>> [r.is_real for r in real_roots(p)] [True, True, True] Using :func:`real_roots` is equivalent to using :func:`~.all_roots` (or :func:`~.rootof`) and filtering out only the real roots: >>> from sympy import all_roots >>> r = [r for r in all_roots(p) if r.is_real] >>> real_roots(p) == r True If only the real roots are wanted then using :func:`real_roots` is faster than using :func:`~.all_roots`. Using :func:`real_roots` avoids complex root isolation which can be a lot slower than real root isolation especially for polynomials of high degree which typically have many more complex roots than real roots. Irrational algebraic coefficients are handled by :func:`real_roots` if `extension=True` is set. >>> from sympy import sqrt, expand >>> p = expand((x - sqrt(2))*(x - sqrt(3))) >>> print(p) x**2 - sqrt(3)*x - sqrt(2)*x + sqrt(6) >>> real_roots(p) Traceback (most recent call last): ... NotImplementedError: sorted roots not supported over EX >>> real_roots(p, extension=True) [sqrt(2), sqrt(3)] Transcendental coefficients cannot currently be handled by :func:`real_roots`. In the case of algebraic or transcendental coefficients :func:`~.ground_roots` might be able to find some roots by factorisation: >>> from sympy import ground_roots >>> ground_roots(p, x, extension=True) {sqrt(2): 1, sqrt(3): 1} If the coefficients are numeric then :func:`~.nroots` can be used to find all roots approximately: >>> from sympy import nroots >>> nroots(p, 5) [1.4142, 1.732] If the coefficients are symbolic then :func:`sympy.polys.polyroots.roots` or :func:`~.ground_roots` should be used instead. >>> from sympy import roots, ground_roots >>> p = x**2 - 3*x*y + 2*y**2 >>> roots(p, x) {y: 1, 2*y: 1} >>> ground_roots(p, x) {y: 1, 2*y: 1} Parameters ========== f : :class:`~.Expr` or :class:`~.Poly` A univariate polynomial with rational (or ``Float``) coefficients. multiple : ``bool`` (default ``True``). Whether to return a ``list`` of roots or a list of root/multiplicity pairs. radicals : ``bool`` (default ``True``) Use simple radical formulae rather than :py:class:`~.ComplexRootOf` for some irrational roots. extension: ``bool`` (default ``False``) Whether to construct an algebraic extension domain before computing the roots. Setting to ``True`` is necessary for finding roots of a polynomial with (irrational) algebraic coefficients but can be slow. Returns ======= A list of :class:`~.Expr` (usually :class:`~.ComplexRootOf`) representing the real roots is returned. The roots are arranged in increasing order and are repeated according to their multiplicities as roots of ``f``. If ``multiple=False`` is passed then a list of root/multiplicity pairs is returned instead. If ``radicals=False`` is passed then all roots will be represented as either rational numbers or :class:`~.ComplexRootOf`. See also ======== Poly.real_roots: The underlying :class:`Poly` method used by :func:`real_roots`. rootof: Compute a single numbered root of a univariate polynomial. all_roots: Compute all real and non-real roots using :func:`~.rootof`. ground_roots: Compute some roots in the ground domain by factorisation. nroots: Compute all roots using approximate numerical techniques. sympy.polys.polyroots.roots: Compute symbolic expressions for roots using radical formulae. References ========== .. [1] https://en.wikipedia.org/wiki/Casus_irreducibilis TrFrrrr) rVrWrSrrrrr<r;rrs rdrrusLE a  !;!;40d+5)!T""155??"">? ? <<< == E ?! CE EErc[USS9n[U[5(d&URR(d [ S5eUR XUS9$![ a [ SU-5ef=f)a$ Compute numerical approximations of roots of ``f``. Examples ======== >>> from sympy import nroots >>> from sympy.abc import x >>> nroots(x**2 - 3, n=15) [-1.73205080756888, 1.73205080756888] >>> nroots(x**2 - 3, n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] Frrz6Cannot compute numerical roots of %s, not a polynomial)rTrr)rWrVrrr<r;r)r_rTrrrs rdrr3sx" J 5 !!T""155??"">? ? 88aG8 << J Dq HJ JJs AAA0c([R"U/5 [U/UQ70UD6up4[U[5(d&UR R (d [S5eUR5$![an[SSU5eSnAff=f)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} rr rN) rqr&rrVrWrrr<r?r@r r*s rdr r Rs $#81D1D1!T""155??"">? ? >>  83778sA A55 B? B  Bcp[R"U/5 [U/UQ70UD6upE[U[5(d&UR R (d [S5eURU5nUR(dUR5$U$![an[SSU5eSnAff=f)an 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 rrrN) rqr&rrVrWrrr<r?r@rrr])r_rTrYrrrrrbs rdrrps0 $#@1D1D1!T""155??"">? ? # #A &F 99~~  @ 63??@sA B B5# B00B5) _signsimpcb^SSKJn SSKJn [R "US/5 [ U5nU(aU"U5n0nSU;aUSUS'[U[5(dZUR(d*[U[5(d[U[5(dU$[USS9nUR5upxO[U5S:XaUupx[U[5(aH[U[5(a3UR US'UR"US 'UR%SS5US'UR'5UR'5pO[)S U-5eSS KJm UR/T5(a [15eU"Xx4/UQ70UD6un upU R2(d7[U[5(dUR55$[6R8Xx4$SU REU 5sn unnUR%SS5(aSU;aU RXUS'[U[5(d$U UR'5UR'5- -$UR'5UR'5nnUR%SS5(dU UU4$U [U/UQ70UD6[U/UQ70UD64$![0Gamn UR:(a!UR/T5(d [1U 5eUR<(dUR>(aj[AURBU4S jSS 9upUVs/sHn[EU5PM Os snfnnURF"[EURF"U 65/UQ76sSn A $/n[IU5n[KU5 UHmn[U[L5(d[U[5(dM/UROU[EU545 URQ5 M^![Ra Mkf=f URU[WU55sSn A $Sn A ff=f)a Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol, together >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2 Note: due to automatic distribution of Rationals, a sum divided by an integer will appear as a sum. To recover a rational form use `together` on the result: >>> cancel(x/2 + 1) x/2 + 1 >>> together(_) (x + 2)/2 r)signsimp)sringrT)radicalr rYrSzunexpected argument: %srcZ>URSL=(a URT5(+$r)rhas)r"rs rdrcancel..s%  D(Ay1A-AArhrNrF)-rrsympy.polys.ringsrrqr&r%rVrrr r rrarrWrYrSr-r]r:rrrr<ngensrr r rrrrOrr9rcr'r r)rskiprsrrvr)r_rrYrrrrrlrrrrmsgrncrrpoterrrs @rdr9r9si21' $ * A QK C$G}G a   ;;*Q 33:a;N;NH D )!1 Q1 a  :a#6#6&&CKHHCM777D1CLyy{AIIK12Q677>* 55  !# #1&04040 6Awwa''xxz!uua{" :188A;IAv1 www6#4iiF a  !))+aiik)**yy{AIIK1www&&a7Nd1+t+s+T!-Bd-Bc-BB BG *  AEE)$4$4!#& & 88qxx"BEA&((R&)R(B(66&,2r2 2D$Q'C Ia--Z45H5HKKF1I/HHJ* ::d4j) )-*sc$A'J6 J66 P.A3P)4M  0P)9P.?A P) ,O75P)7 PP)PP)#P.)P.c[R"USS/5 [U/[U5-/UQ70UD6upEUR nSnUR(aEUR(a4UR(d#URSUR505nSnSS K J n U "URUR UR5up[!U5HKupU R#UR 5R$R'5n U R)U 5XL'MM USR+US S5upUVs/sH"n[,R/[1U5U5PM$ nn[,R/[1U5U5nU(a5UVs/sHnUR35PM snUR35nnUUpUR6(d1UVs/sHnUR95PM snUR954$X4$![an[ SSU5eSnAff=fs snfs snf![4a Nzf=fs snf) 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) rrreducedrNFrSTxringr)rqr&r ryr?r@rSrrrrr/rrrYrnrrrlrrrrWrwrvr@r9rr])r_rrYrrrrrSrNr_ringrrrzrrr_Q_rs rdr r s( $& 123,aS47]JTJTJ ZZFG xxFNN6??ii6#3#3#567'SXXszz3995HEU#szz*..668??4($ 8<<ab "DA0121a# &A2 Q%A +,-1aaiik1-qyy{Brq 99%&'Q Q'44t C 3 1c223& 3 .    (sGH)H.H8H34H8I H+ H&&H+3H88 IIc [U/UQ70UD6$)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]_ ) GroebnerBasisrrYrs rdr1r1<sf  *T *T **rhc4[U/UQ70UD6R$); Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 )ris_zero_dimensionalrs rdrrrs  *T *T * > >>rhc\rSrSrSrSr\S5r\S5r \S5r \S5r \S5r \S 5r \S 5rS rS rS rSrSrSr\S5rSrSSjrSrSrg)riz%Represents a reduced Groebner basis. c.[R"USS/5 [U/UQ70UD6upESSKJn U"URURUR5nUV s/sH4o(dM URU RR55PM6 nn [XHURS9n U V s/sHn [ R#X5PM n n UR%X5$![an[ S[ U5U5eSnAff=fs sn fs sn f)z>Compute a reduced Groebner basis for a system of polynomials. rrr1Nr)PolyRingr)rqr&r r?r@rrrrYrSrnrrlr _groebnerrrWrw_new) rrrYrrrrrringrzrr`s rdrGroebnerBasis.__new__sdWh$78 =0BTBTBJE /#**cii8@EN3 0 0 23N e#** 5./ 0aT__Q $a 0xx" =#JA< < = O 1s)C% D ,-D 3D% D /DD c^[R"U5n[U5UlX#lU$r)rrrh_basis_options)rbasisrqrs rdrGroebnerBasis._news%mmC 5\   rhcpSUR5n[U6[URR64$)Nc3@# UHoR5v M g7frr)rSrls rdrT%GroebnerBasis.args..s2kks)r rr!rY)rr"s rdrGroebnerBasis.argss.2dkk2u udmm&8&89::rhc`URVs/sHoR5PM sn$s snfr)r r]rrzs rdr GroebnerBasis.exprss"+/;;7;4 ;777s+c,[UR5$r)ryr rs rdrGroebnerBasis.polyssDKK  rhc.URR$r)r!rYrs rdrYGroebnerBasis.genss}}!!!rhc.URR$r)r!rSrs rdrSGroebnerBasis.domains}}###rhc.URR$r)r!rnrs rdrnGroebnerBasis.orders}}"""rhc,[UR5$r)rr rs rd__len__GroebnerBasis.__len__s4;;rhcURR(a[UR5$[UR5$r)r!riterr rs rdreGroebnerBasis.__iter__s- ==   # # # #rhcxURR(aURnX!$URnX!$r)r!rr )ritemr"s rd __getitem__GroebnerBasis.__getitem__s5 ==  JJE{JJE{rhcr[UR[URR 5545$r)hashr rhr!rrs rdrGroebnerBasis.__hash__s(T[[% (;(;(=">?@@rhc8[XR5(a9URUR:H=(a URUR:H$[ U5(a7UR [ U5:H=(d UR[ U5:H$g)NF)rVrr r!rNrryr rrs rdrGroebnerBasis.__eq__sg e^^ , ,;;%,,.R4==ENN3R R e__::e,I d5k0I Irhc X:X+$rr+rAs rdrGroebnerBasis.__ne__s   rhcSn[S/[UR5-5nURRnUR H%nUR US9nU"U5(dM!X%-nM' [U5$)rc:[[[U55S:H$r)sumrr)monomials rd single_var5GroebnerBasis.is_zero_dimensional..single_varss4*+q0 0rhrrW)r2rrYr!rnrr r)rrIrrnrzrHs rdr!GroebnerBasis.is_zero_dimensionalsn 1aSTYY/0  ##JJDwwUw+H(##% 9~rhc0URnURn[U5nX4:XaU$UR(d [ S5e[ UR 5nURnURUR5US.5nSSK J n U"URURU5up[U5HKupU RUR5RR!5n UR#U 5XZ'MM [%XXU5n U V s/sH"n [&R)[+U 5U5PM$ n n UR,(d'U V s/sHoR/SS9SPM n n XblUR1X5$s sn fs sn f)a1 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)rSrnrr Tr%r)r!rnr3rrsryr rSrr/rrrYrrrlrrr0rWrwrvrrr)rrnr src_order dst_orderrrSrrrrrzrr`s rdfglmGroebnerBasis.fglmsP>mmII  '  !K''%&gh hT[[!ii&&(   ,3::y9 'GA??3::.22::>> from sympy import groebner, expand, Poly >>> 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 # Using Poly input >>> f_poly = Poly(f, x, y) >>> G = groebner([Poly(x**3 - x), Poly(y**3 - y)]) >>> G.reduce(f_poly) ([Poly(2*x, x, y, domain='ZZ'), Poly(1, x, y, domain='ZZ')], Poly(x**2 + y**2 + y, x, y, domain='ZZ')) z;Polynomial generators don't match Groebner basis generatorsFrSTrr rN)rVrWrYr!r:rrSr}ryr rrrr/rrrnrrlrrrrwrvr@r9rr])rrrrzrrrSrNrrrrrrrrrs rdrGroebnerBasis.reduce>sF dD ! !yyDMM... !^__??4==#7#78D??47Ddkk**mm FNN6??))Xv'7'7'9:;CG+3::syy9 'GA??3::.22::J J>J JJc0URU5SS:H$)a  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 rr)rr)s rdcontainsGroebnerBasis.containss&{{4 #q((rhr+Nr)r^rrrrrrrrrr rrYrSrnr4rer;rrrrrOrrTrr+rhrdrrs/ &;;88!!""$$## $ A!>@!DN`)rhrc^^[R"T/5 UU4Sjm[U5nUR(a[ U/UQ70TD6$ST;aSTS'[R "UT5nT"X5$)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>//p2[R"U5GHn//pe[R"U5HnUR(aUR T "Xq55 M-UR (aUR R(ahURR(aMURS:a=UR T "UR U5RUR55 MUR U5 M U(dUR U5 GMUSnUSSHnURU5nM U(aB[U6nUR(aX-nO$UR[RXq55nUR U5 GM U(d[RX5n OkUSn USSHnU RU5n M U(aB[U6nUR(aX- n O$U R[RXA55n U R"UR!SS50T D6$)NrrrYr+)r rrrrrrrrrrrrWr}r9rr-) rrr3 poly_termsrzr poly_factorsr productrb_polyrs rdr[poly.._polyszMM$'D$&\---== ''f(:;]]v{{'9'9 --&**/ ''fkk3/33FJJ?ANN6*.  T"&q/*12.F%kk&1G/ ']F'')")++doof.J"K!!'*;(>__T/F]F"12D)'E{>>NF#ZZ(BCF~~swwvr2;d;;rhrF)rqr&r%r{rWrr)rrYrrr[s ` @rdrzrzsp $#2r?r@rAsympy.polys.polyutilsrBrCrDrErFrGsympy.polys.rationaltoolsrHsympy.polys.rootisolationrIsympy.utilitiesrJrKrLsympy.utilities.exceptionsrMsympy.utilities.iterablesrNrOrrmpmath.libmp.libhyperrPrgrWrrrr r rrrrrr rrrrrrrrrr?rCrGrMrPrUr_r_rdrnrhrrkrorsrvrzr}rrrrrrrrrrrrrrrrrr rrrrrrr rr9r rrrzrar+rhrdrs >"#,#,AAMM*+#776&+0>+.4**;-;*.11    /A55@4 /!JPE`5PE`PE`fJZtZZz&& %P00 [|7N7Nt11h((4!!02!!2::DD>>>D##L##L00f:&+!!H:%%PQQh00fJJZ//dr3r3j::0**Z:::++\<<   F:= $ 6 :#z )FX8|~)X=="88"@@"__D44nUU8++@d=d=Nz>z>z==<:((V#`C`CF88v2+2+j??"\)E\)\)~NNb"-rh