ЦiF%SrSSKJr SSKJr SSKJrJrJrJ r J r J r SSK J r SSKJr SSKJr SSKJr SS KJrJr SS KJrJr SS KJr SS KJr SS KJ r SSK!J"r"J#r#J$r$ SSK%J&r& SSK'J(r( SSK)J*r* SSK+J,r, SSK-J.r. SSK/J0r0J1r1J2r2J3r3 SSK4J5r6J7r8J9r9 SSK:J;r;JJ?r? SSK@JArAJBrB SSKCJDrD SSKEJFrF \A\.4Sj5rG\A\.4Sj5rH\A\.4Sj5rI\AS5rJSrK0rLS \MS!'"S"S#\?\5rN"S$S%\&\?\\O5rPg&)'zSparse polynomial rings. ) annotations)Any)addmulltlegtge)reduce) GeneratorType)Expr)igcd)Symbolsymbols) CantSympifysympify)multinomial_coefficients)IPolys)construct_domain)ninf dmp_to_dict dmp_from_dict) DomainElementPolynomialRingheugcd) MonomialOps)lex)CoercionFailedGeneratorsErrorExactQuotientFailedMultivariatePolynomialError)DomainOrder build_options)expr_from_dict _dict_reorder_parallel_dict_from_expr)DefaultPrinting)publicsubsets) is_sequence)pollutec:[XU5nU4UR-$)aRConstruct a polynomial ring returning ``(ring, x_1, ..., x_n)``. Parameters ========== symbols : str Symbol/Expr or sequence of str, Symbol/Expr (non-empty) domain : :class:`~.Domain` or coercible order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex`` Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex >>> R, x, y, z = ring("x,y,z", ZZ, lex) >>> R Polynomial ring in x, y, z over ZZ with lex order >>> x + y + z x + y + z >>> type(_) PolyRinggensrdomainorder_rings P/var/www/html/ai-image-ml/venv/lib/python3.13/site-packages/sympy/polys/rings.pyringr8#s!8 We ,E 8ejj  c4[XU5nX3R4$)aXConstruct a polynomial ring returning ``(ring, (x_1, ..., x_n))``. Parameters ========== symbols : str Symbol/Expr or sequence of str, Symbol/Expr (non-empty) domain : :class:`~.Domain` or coercible order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex`` Examples ======== >>> from sympy.polys.rings import xring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex >>> R, (x, y, z) = xring("x,y,z", ZZ, lex) >>> R Polynomial ring in x, y, z over ZZ with lex order >>> x + y + z x + y + z >>> type(_) r0r3s r7xringr;Bs8 We ,E :: r9c[XU5n[URVs/sHoDRPM snUR5 U$s snf)a\Construct a polynomial ring and inject ``x_1, ..., x_n`` into the global namespace. Parameters ========== symbols : str Symbol/Expr or sequence of str, Symbol/Expr (non-empty) domain : :class:`~.Domain` or coercible order : :class:`~.MonomialOrder` or coercible, optional, defaults to ``lex`` Examples ======== >>> from sympy.polys.rings import vring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex >>> vring("x,y,z", ZZ, lex) Polynomial ring in x, y, z over ZZ with lex order >>> x + y + z # noqa: x + y + z >>> type(_) )r1r.rnamer2)rr4r5r6syms r7vringr?as=6 We ,E %-- 1-3hh- 15::> L 2sA c Sn[U5(dU/Sp0[[[U55n[ X5n[ X5upTUR c[UVs/sHn[UR55PM sn/5n[XtS9uUln[[Xx55n UVV V s/sH*ofR5V V s0sH upXU _M sn n PM, nn nn [URUR UR5n [[U R U55n U(aXS4$X4$s snfs sn n fs sn n nf)a Construct a ring deriving generators and domain from options and input expressions. Parameters ========== exprs : :class:`~.Expr` or sequence of :class:`~.Expr` (sympifiable) symbols : sequence of :class:`~.Symbol`/:class:`~.Expr` options : keyword arguments understood by :class:`~.Options` Examples ======== >>> from sympy import sring, symbols >>> x, y, z = symbols("x,y,z") >>> R, f = sring(x + 2*y + 3*z) >>> R Polynomial ring in x, y, z over ZZ with lex order >>> f x + 2*y + 3*z >>> type(_) FT)optr)r-listmaprr&r)r4sumvaluesrdictzipitemsr1r2r5 from_dict)exprsroptionssinglerArepsrepcoeffs coeffs_dom coeff_mapmcr6polyss r7sringrUs4F u  v We$ %E  )C)4ID zzT;TctCJJL)T;R@!1&!B JV01 EIJTcYY[9[TQaL[9TJ SXXszz399 5E U__d+ ,E Qx  ~< :Js#E4E EEEc.[U[5(aU(a [USS9$S$[U[5(aU4$[ U5(a;[ SU55(a [U5$[ SU55(aU$[ S5e)NT)seqc3B# UHn[U[5v M g7fN) isinstancestr.0ss r7 !_parse_symbols..s37az!S!!7c3B# UHn[U[5v M g7frZ)r[r r]s r7r`ras6gAt$$grbzbexpected a string, Symbol or expression or a non-empty sequence of strings, Symbols or expressions)r[r\_symbolsr r-allr!rs r7_parse_symbolsrgs'3.5xT*=2= GT " "z W   373 3 3G$ $ 6g6 6 6N ~ r9zdict[Any, Any] _ring_cachec&\rSrSrSr\4SjrSrSrSr Sr Sr S r S'S jr S r\S 5r\S5rS(SjrSrSrSr\rS(SjrS(SjrSrSrSrSrSrSrSrSr Sr!\S5r"\S5r#S r$S!r%S"r&S#r'S$r(S%r)S&r*g ))r1z*Multivariate distributed polynomial ring. c^[[U55n[U5n[R"U5n[ R"T5mUR XUT4n[RU5nUGc^UR(a1[U5[UR5-(a [S5e[RU5nXVl[!U5Ul[%S[&4SU05UlXl XFlX&lTUlSU-UlUR35Ul[UR45UlUR0UR84/UlU(a[=U5nUR?5Ul URC5Ul"URG5Ul$URK5Ul&URO5Ul(URS5Ul*URW5Ul,O/SnXl Xl"SUl$Xl&Xl(Xl*Xl,T[ZLa [\Ul/O U4SjUl/[aURUR45HFup[cU [d5(dMU Rfn [iXk5(aM:[kXkU 5 MH U[U'U$)Nz7polynomial ring and it's ground domain share generators PolyElementr8rcgNrXrX)abs r7"PolyRing.__new__..srr9cgrorX)rprqrSs r7rrrssbr9c>[UTS9$)Nkey)max)fr5s r7rrrss S->r9)6tuplerglen DomainOpt preprocessOrderOpt__name__rhget is_Compositesetrr!object__new__ _hash_tuplehash_hashtyperldtypengensr4r5 zero_monom_gensr2 _gens_setone_onerr monomial_mulpow monomial_powmulpowmonomial_mulpowldiv monomial_ldivdiv monomial_divlcm monomial_lcmgcd monomial_gcdrrx leading_expvrGr[rr=hasattrsetattr) clsrr4r5rrobjcodegenmonunitsymbol generatorr=s ` r7rPolyRing.__new__s%w/0G %%f-##E*||WVUC ook* ;""s7|c&..6I'I%&_``..%C)O[)CI][NVSMJCI!KIJCI!%ZCNyy{CHMCM45CH%e,#*;;= #*;;= &-nn&6#$+LLN!#*;;= #*;;= #*;;= )#* #* &8#$+!#* #* #* |#& #> %(chh%?!ff--!;;D"3--95 &@(+K $ r9cURRn/n[UR5H5nUR U5nUR nXU'UR U5 M7 [U5$)z(Return a list of polynomial generators. )r4rrangermonomial_basiszeroappendrz)selfrriexpvpolys r7rPolyRing._genss_kkootzz"A&&q)D99DJ LL  # U|r9cHURURUR4$rZ)rr4r5rs r7__getnewargs__PolyRing.__getnewargs__s dkk4::66r9cURR5nUS UHnURS5(dMX M U$)Nr monomial_)__dict__copy startswith)rstaterws r7 __getstate__PolyRing.__getstate__sA ""$ . !C~~k**J r9cUR$rZrrs r7__hash__PolyRing.__hash__ s zzr9c[U[5=(a] URURURUR 4URURURUR 4:H$rZ)r[r1rr4rr5rothers r7__eq__PolyRing.__eq__#sV%*D \\4;; DJJ ? ]]ELL%++u{{ C D Dr9c X:X+$rZrXrs r7__ne__PolyRing.__ne__(s   r9NcURU=(d URU=(d URU=(d UR5$rZ) __class__rr4r5)rrr4r5s r7clonePolyRing.clone+s3~~g5v7LeNaW[WaWabbr9c@S/UR-nSX!'[U5$)zReturn the ith-basis element. r)rrz)rrbasiss r7rPolyRing.monomial_basis.s"DJJU|r9c"UR5$rZ)rrs r7r PolyRing.zero4szz|r9c8URUR5$rZ)rrrs r7r PolyRing.one8szz$))$$r9c8URRX5$rZ)r4convertrelement orig_domains r7 domain_newPolyRing.domain_new<s{{""788r9c:URURU5$rZ)term_newr)rcoeffs r7 ground_newPolyRing.ground_new?s}}T__e44r9cVURU5nURnU(aX#U'U$rZ)rr)rmonomrrs r7rPolyRing.term_newBs(&yy K r9c[U[5(apXR:XaU$[UR[5(a5URRUR:XaUR U5$[ S5e[U[5(a [ S5e[U[5(aURU5$[U[5(aURU5$[U[5(aURU5$UR U5$![a URU5s$f=f)N conversionparsing)r[rlr8r4rrNotImplementedErrorr\rFrIrB from_terms ValueError from_listr from_exprrrs r7ring_newPolyRing.ring_newIs g{ + +||#DKK88T[[=M=MQXQ]Q]=]w//),77  % %%i0 0  & &>>'* *  & & /w// & &>>'* *??7+ +  /~~g.. /s"D**EEcURnURnUR5HupVU"Xb5nU(dMXdU'M U$rZ)rrrH)rrrrrrrs r7rIPolyRing.from_dictasC__ yy#MMOLEu2Eu#U ,  r9c8UR[U5U5$rZ)rIrFrs r7rPolyRing.from_termsls~~d7m[99r9cfUR[XRS- UR55$Nr)rIrrr4rs r7rPolyRing.from_listos$~~k'::a<MNNr9cV^^^^TRmUUUU4SjmT"[U55$)Nc >TRU5nUbU$UR(a-[[[ [ TUR 555$UR(a-[[[ [ TUR 555$UR5up#UR(aUS:aT"U5[U5-$TRTRU55$r)ris_Addr rrBrCargsis_Mulr as_base_exp is_Integerintrr)exprrbaseexp_rebuildr4mappingrs r7r(PolyRing._rebuild_expr.._rebuildus D)I$  c4Hdii(@#ABBc4Hdii(@#ABB!,,. >>cAg#D>3s833??6>>$+?@@r9)r4r)rrrrr4s` `@@r7 _rebuild_exprPolyRing._rebuild_exprrs) A A$ &&r9c[[[URUR555nUR X5nUR U5$![a [SU<SU<35ef=f)Nz6expected an expression convertible to a polynomial in z, got ) rFrBrGrr2rrr r)rrrrs r7rPolyRing.from_exprsktC dii89: '%%d4D==& & pcgimno o ps AA4cVUcUR(aSnU$SnU$[U[5(aGUnSU::aX R:aU$UR*U::aUS::aU*S- nU$[SU-5e[XR5(aUR R U5nU$[U[5(aURR U5nU$[SU-5e![a [SU-5ef=f![a [SU-5ef=f)z+Compute index of ``gen`` in ``self.gens``. rrzinvalid generator index: %szinvalid generator: %szEexpected a polynomial generator, an integer, a string or None, got %s) rr[rrrr2indexr\r)rgenrs r7r PolyRing.indexsI ;zz2/.-S ! !AAv!jj.$#**!a2gBF !!>!DEE ZZ ( ( @IIOOC(S ! ! @LL&&s+ dgjjk k @ !83!>?? @  @ !83!>?? @sC3D3D D(c[[URU55n[UR5VVs/sHup4X2;dM UPM nnnU(d UR $UR US9$s snnf)z,Remove specified generators from this ring. rf)rrCr  enumeraterr4r)rr2indicesrr_rs r7drop PolyRing.dropsac$**d+,"+DLL"9O"9$!Q=MA"9O;; ::g:. . Ps A2A2cdURUnU(d UR$URUS9$)Nrf)rr4r)rrwrs r7 __getitem__PolyRing.__getitem__s.,,s#;; ::g:. .r9cURR(d[URS5(a#URURRS9$[ SUR-5e)Nr4r4z%s is not a composite domain)r4rrrrrs r7 to_groundPolyRing.to_groundsO ;; # #wt{{H'E'E::T[[%7%7:8 8;dkkIJ Jr9c[U5$rZrrs r7 to_domainPolyRing.to_domains d##r9c^SSKJn U"URURUR5$)Nr) FracField)sympy.polys.fieldsrrr4r5)rrs r7to_fieldPolyRing.to_fields 0t{{DJJ??r9c2[UR5S:H$rr{r2rs r7 is_univariatePolyRing.is_univariates499~""r9c2[UR5S:$rr"rs r7is_multivariatePolyRing.is_multivariates499~!!r9cURnUH-n[U[S9(aX R"U6- nM)X#- nM/ U$)a Add a sequence of polynomials or containers of polynomials. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> R, x = ring("x", ZZ) >>> R.add([ x**2 + 2*i + 3 for i in range(4) ]) 4*x**2 + 24 >>> _.factor_list() (4, [(x**2 + 6, 1)]) include)rr-r rrobjsprs r7r PolyRing.adds?" IIC3 6XXs^#  r9cURnUH-n[U[S9(aX R"U6-nM)X#-nM/ U$)ap Multiply a sequence of polynomials or containers of polynomials. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> R, x = ring("x", ZZ) >>> R.mul([ x**2 + 2*i + 3 for i in range(4) ]) x**8 + 24*x**6 + 206*x**4 + 744*x**2 + 945 >>> _.factor_list() (1, [(x**2 + 3, 1), (x**2 + 5, 1), (x**2 + 7, 1), (x**2 + 9, 1)]) r))rr-r rr+s r7r PolyRing.muls?" HHC3 6XXs^#  r9cb[[URU55n[UR5VVs/sHup4X2;dM UPM nnn[UR 5VVs/sHup6X2;dM UPM nnnU(dU$UR XPR"U6S9$s snnfs snnf)zL Remove specified generators from the ring and inject them into its domain. rr4)rrCr rrr2rr)rr2rrr_rr s r7drop_to_groundPolyRing.drop_to_grounds c$**d+,!*4<D::d4j:1 1Kr9c[UR5R[U55nUR[ U5S9$)z9Add the elements of ``symbols`` as generators to ``self``rfr6)rrr8s r7add_gensPolyRing.add_gens&s44<< &&s7|4zz$t*z--r9c^US:dXR:a[SU<SUR<35eU(d UR$URn[ [ UR5[U55HRm[U4Sj[ UR555nX RX0RR5- nMT U$)zW Return the elementary symmetric polynomial of degree *n* over this ring's generators. rz.Cannot generate symmetric polynomial of order z for c3@># UHn[UT;5v M g7frZ)r)r^rr_s r7r`*PolyRing.symmetric_poly..7sE3Dac!q&kk3D) rrr2rrr,rrrzrr4)rnrrr_s @r7symmetric_polyPolyRing.symmetric_poly+s q5A NZ[]a]f]fgh h88O99DU4::.A7E53DEE e[[__==8Kr9rX)NNNrZ)+r __module__ __qualname____firstlineno____doc__rrrrrrrrrrpropertyrrrrrr__call__rIrrrrr rrrrrr#r&rrr3r9r<rC__static_attributes__rXr9r7r1r1s4,/?B 7D !c %%95,,H :O'.'>//K$@##""66 H. r9r1c\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSSjrSrSrSrSrSrSrSrSrSrSrSrSrSr\ S5r!\ S5r"\ S 5r#\ S!5r$\ S"5r%\ S#5r&\ S$5r'\ S%5r(\ S&5r)\ S'5r*\ S(5r+\ S)5r,\ S*5r-\ S+5r.\ S,5r/\ S-5r0\ S.5r1S/r2S0r3S1r4S2r5S3r6S4r7S5r8S6r9S7r:S8r;S9rS<r?S=r@S>rAS?rBS@rC\BrD\CrESArFSBrGSCrHSDrISErJSFrKSGrLSSHjrMSIrNSSJjrOSKrPSLrQSMrRSNrSSOrT\ SP5rU\ SQ5rVSRrW\ SS5rXSTrYSUrZSSVjr[SSWjr\SSXjr]SYr^SZr_S[r`S\raS]rbS^rcS_rdS`reSarfSbrgScrhSdriSerjSfrkSgrlShrm\mrnSiroSjrpSkrqSlrrSmrsSnrtSoruSprvSqrwSrrxSsryStrzSur{Svr|Swr}Sxr~SyrSzrSS{jrSS|jrS}rSS~jrSrSSjrSSjrSSjrSSjrSSjrSrSrSrSrSrSrSrSrSrSrSrSrSSjrSrSrg)rli<z5Element of multivariate distributed polynomial ring. c$URU5$rZ)r)rinits r7newPolyElement.new?s~~d##r9c6URR5$rZ)r8rrs r7parentPolyElement.parentBsyy""$$r9cLUR[UR554$rZ)r8rB itertermsrs r7rPolyElement.__getnewargs__Es 4 0122r9NcURnUc5[UR[UR 5545=UlnU$rZ)rrr8 frozensetrH)rrs r7rPolyElement.__hash__Js<   =!%tyy)DJJL2I&J!K KDJ r9c$URU5$)aReturn a copy of polynomial self. Polynomials are mutable; if one is interested in preserving a polynomial, and one plans to use inplace operations, one can copy the polynomial. This method makes a shallow copy. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> R, x, y = ring('x, y', ZZ) >>> p = (x + y)**2 >>> p1 = p.copy() >>> p2 = p >>> p[R.zero_monom] = 3 >>> p x**2 + 2*x*y + y**2 + 3 >>> p1 x**2 + 2*x*y + y**2 >>> p2 x**2 + 2*x*y + y**2 + 3 )rOrs r7rPolyElement.copyUs4xx~r9c tURU:XaU$URRUR:wa^[[[ XRRUR565nUR X RR 5$URXRR 5$rZ)r8rrBrGr(rr4rI)rnew_ringtermss r7set_ringPolyElement.set_ringqs 99 K YY  ("2"2 2mD))2C2CXEUEUVWXE&&uii.>.>? ?%%dII,<,<= =r9cU(dURRnOS[U5URR:wa0[ SURR<S[U5<35e[ UR 5/UQ76$)Nz"Wrong number of symbols, expected z got )r8rr{rrr' as_expr_dict)rrs r7as_exprPolyElement.as_exprzsfii''G \TYY__ ,#g,0  d//1>;KL;K<5x&;KLLLsA c URRnUR(aUR(dURU4$UR 5nURnUR nURnUR5HnU"X5"U55nM URUR5VVs/sH upxXxU-4PM snn5n X94$s snnfrZ) r8r4is_Fieldhas_assoc_Ringrget_ringrdenomrErOrH) rr4 ground_ringcommonrrlrkvrs r7 clear_denomsPolyElement.clear_denomss!!f&;&;::t# #oo' oo [[]Eu.F#xxDJJLBLDA1h-LBC|Cs>C c^[UR55HupU(aMX M g)z+Eliminate monomials with zero coefficient. NrBrH)rrorps r7 strip_zeroPolyElement.strip_zeros#&DA1G'r9cU(dU(+$[U[5(a/URUR:Xa[R X5$[ U5S:agUR URR5U:H$)zEquality test for polynomials. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p1 = (x + y)**2 + (x - y)**2 >>> p1 == 4*x*y False >>> p1 == 2*(x**2 + y**2) True rF)r[rlr8rFrr{rrp1p2s r7rPolyElement.__eq__se"6M K ( (RWW-?;;r& & Wq[66"'',,-3 3r9c X:X+$rZrXrxs r7rPolyElement.__ne__s |r9c URn[XR5(ax[UR 55[UR 55:wagUR R nUR 5HnU"XXU5(aM g g[U5S:agUR RU5nUR R UR5X5$![a gf=f)z+Approximate equality test for polynomials. FTr) r8r[rrkeysr4almosteqr{rconstr )ryrz tolerancer8rros r7rPolyElement.almosteqsww b** % %2779~RWWY/{{++HWWYrui88  Wq[ G[[((,{{++BHHJFF"  s0C55 DDc8[U5UR54$rZ)r{r^rs r7sort_keyPolyElement.sort_keysD 4::<((r9c[XRR5(a%U"UR5UR55$[$rZ)r[r8rrNotImplemented)ryrzops r7_cmpPolyElement._cmps4 b''-- ( (bkkmR[[]3 3! !r9c.URU[5$rZ)rrrxs r7__lt__PolyElement.__lt__wwr2r9c.URU[5$rZ)rrrxs r7__le__PolyElement.__le__rr9c.URU[5$rZ)rr rxs r7__gt__PolyElement.__gt__rr9c.URU[5$rZ)rr rxs r7__ge__PolyElement.__ge__rr9cURnURU5nURS:Xa X2R4$[ UR 5nXC X2R US94$)Nrrf)r8r rr4rBrrrr r8rrs r7_dropPolyElement._dropsVyy JJsO ::?kk> !4<<(G jjj11 1r9cjURU5up#URRS:Xa0UR(aUR S5$[ SU-5eUR nUR5H5upVXRS:Xa[U5nXr Xd[U5'M)[ SU-5e U$)NrzCannot drop %sr) rr8r is_groundrrrrHrBrz)rr rr8rrorpKs r7rPolyElement.drops**S/ 99??a ~~zz!}$ !1C!78899D 419QA%&qN$%5%;<< %Kr9cURnURU5n[UR5nXC X2R XBUS94$)Nr2)r8r rBrrrs r7_drop_to_groundPolyElement._drop_to_groundsCyy JJsOt||$ J**W!W*===r9cURRS:Xa [S5eURU5up#URnUR R SnUR5HQupVUSUXRS-S-nXt;aXU-RU5XG'M1XG==XU-RU5- ss'MS U$)Nrz$Cannot drop only generator to groundr) r8rrrrr4r2rU mul_ground)rr rr8rrrmons r7r3PolyElement.drop_to_grounds 99??a CD D&&s+yykkq! NN,LE)eaCDk)C (]66u=  c8m77>> - r9cp[XRRS- URR5$r)rr8rr4rs r7to_densePolyElement.to_dense s&T99??1#4dii6F6FGGr9c[U5$rZ)rFrs r7to_dictPolyElement.to_dict#s Dzr9c~U(d/URURRR5$USnUSnURnURnUR n UR n /n UR5GHtupURRU 5nU(aSOSnU RU5 X:Xa4URU 5nU(aURS5(aUSSnO@U(aU *n XRRR:waURXSS9nOS n/n[U 5HnU UnU(dMURUUUSS9nUS:waAU[U5:wdUS :aURUUS S9nOUnURUUU4-5 MlURS U-5 M U(aU/U-nU RURU55 GMw U S S ;a)U R!S 5nUS:XaU R#S S5 S RU 5$)NMulAtom -  + -rT)strictrFz%s)rr)_printr8r4rrrrr^ is_negativerrr parenthesizerrjoinpopinsert)rprinter precedence exp_pattern mul_symbolprec_mul prec_atomr8rrzmsexpvsrrnegativesignscoeffsexpvrrrsexpheads r7r\PolyElement.str&s>>$))"2"2"7"78 8e$v& yy,,  __::LL/"5( MM*//%0 1?(@ !9 &::a=Du} a%wwvr9c2XRR;$rZ)r8rrs r7 is_generatorPolyElement.is_generatorVsyy****r9czU(+=(d. [U5S:H=(a URRU;$r)r{r8rrs r7rPolyElement.is_groundZs+xLCINKtyy/C/Ct/KLr9cfU(+=(d$ [U5S:H=(a URS:H$r)r{LCrs r7 is_monomialPolyElement.is_monomial^s$x# UHn[U5S:*v M g7frNrDr^rs r7r`(PolyElement.is_linear..?u3u:?re itermonomsrs r7 is_linearPolyElement.is_linear? ???r9cB[SUR555$)Nc3># UHn[U5S:*v M g7f)Nrrs r7r`+PolyElement.is_quadratic..rrrrs r7 is_quadraticPolyElement.is_quadraticrr9cpURR(dgURRU5$NT)r8r dmp_sqf_prs r7 is_squarefreePolyElement.is_squarefrees%vv||vv""r9cpURR(dgURRU5$r)r8rdmp_irreducible_prs r7is_irreduciblePolyElement.is_irreducibles%vv||vv''**r9cURR(aURRU5$[S5e)Nzcyclotomic polynomial)r8r#dup_cyclotomic_pr#rs r7 is_cyclotomicPolyElement.is_cyclotomics0 66  66**1- --.EF Fr9czURUR5VVs/sH upX*4PM snn5$s snnfrZ)rOrU)rrrs r7__neg__PolyElement.__neg__s2xxdnn>NP>Nle5&/>NPQQPs7 cU$rZrXrs r7__pos__PolyElement.__pos__s r9cU(dUR5$URn[XR5(agUR5nURnUR R nUR5HupgU"Xe5U-nU(aXsU'MX6 M! U$[U[5(a[UR [5(a%UR RUR:XaOd[URR [5(a5URR RU:XaURU5$[$URU5nUR5nU(dU$URn XR5;aXU 'U$XU *:XaX9 U$X9==U- ss'U$![a [s$f=f)zAdd two polynomials. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> (x + y)**2 + (x - y)**2 2*x**2 + 2*y**2 )rr8r[rrr4rrHrlr__radd__rrrrr ) ryrzr8r-rrrorpcp2rs r7__add__PolyElement.__add__s779 ww b** % % A%%C;;##D L1$aD # H K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% //"%C AB"" H B%<HESLEH "! ! "s#G G G cUR5nU(dU$URnURU5nURnX@R 5;aXU'U$XU*:XaX$ U$X$==U- ss'U$![ a [ s$f=frZ)rr8rrrr r)ryrBr-r8rs r7rPolyElement.__radd__s GGIHww "AB"" H 2;HEQJEH "! ! "sA88B  B cU(dUR5$URn[XR5(agUR5nURnUR R nUR5HupgU"Xe5U- nU(aXsU'MX6 M! U$[U[5(a[UR [5(a%UR RUR:XaOd[URR [5(a5URR RU:XaURU5$[$URU5nUR5nURnXR5;aU*X8'U$XU:XaX8 U$X8==U-ss'U$![a [s$f=f)zSubtract polynomial p2 from p1. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p1 = x + y**2 >>> p2 = x*y + y**2 >>> p1 - p2 -x*y + x )rr8r[rrr4rrHrlr__rsub__rrrrr ) ryrzr8r-rrrorprs r7__sub__PolyElement.__sub__s~ 779 ww b** % % A%%C;;##D L1$aD # H K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% $B AB" H 2;HERKEH "! ! "s#GGGcURnURU5nURnUH nX*X4'M X1- nU$![a [s$f=f)zn - p1 with n convertible to the coefficient domain. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p = x + y >>> 4 - p -x - y + 4 )r8rrr r)ryrBr8r-rs r7r PolyElement.__rsub__'scww "A A8) FAH "! ! "sAAAcURnURnU(aU(dU$[XR5(aURnUR RnUR n[UR55nUR5H'upUHupU"X5n U"X5X--X<'M M) UR5 U$[U[5(a[UR [5(a%UR RUR:XaOd[URR [5(a5URR RU:XaURU5$[$URU5nUR5HupX-n U (dMXU'M U$![a [s$f=f)zMultiply two polynomials. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', QQ) >>> p1 = x + y >>> p2 = x - y >>> p1*p2 x**2 - y**2 )r8rr[rrr4rrBrHrurlr__rmul__rrr )ryrzr8r-rrrp2itexp1v1exp2v2rrps r7__mul__PolyElement.__mul__Bsy ww IIH JJ ' '%%C;;##D,,L #DHHJ $HD&t2C ^be3AF!%' LLNH K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% $BHHJE1dG'H "! ! "sGG%$G%cURRnU(dU$URRU5nUR5Hup4X-nU(dMXRU'M U$![a [ s$f=f)zp2 * p1 with p2 in the coefficient domain of p1. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p = x + y >>> 4 * p 4*x + 4*y )r8rrrHr r)ryrzr-r(r)rps r7r&PolyElement.__rmul__tsw GGLLH ""2&BHHJE1dG'H "! ! "sA((A;:A;cURnU(dU(a UR$[S5e[U5S:Xao[ UR 55Sup4UR nXBRR:XaXEURX15'U$XA-XRRX15'U$[U5nUS:a [S5eUS:XaUR5$US:XaUR5$US:XaXR5-$[U5S::aURU5$URU5$)zraise polynomial to power `n` Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> _, x, y = ring('x, y', ZZ) >>> p = x + y**2 >>> p**3 x**3 + 3*x**2*y**2 + 3*x*y**4 + y**6 z0**0rrzNegative exponentr)r8rrr{rBrHrr4rrrsquare_pow_multinomial _pow_generic)rrBr8rrr-s r7__pow__PolyElement.__pow__syyxx (( Y!^ -a0LE A '16$##E-.H27##E-.H F q501 1 !V99;  !V;;= !V % % Y!^((+ +$$Q' 'r9cURRnUnUS-(aX#-nUS-nU(dU$UR5nUS-nM4)Nrr)r8rr3)rrBr-rSs r7r5PolyElement._pow_genericsV IIMM 1uCQ  AQAr9c[[U5U5R5nURRnURR nUR5nURR RnURRnUHpupUn U n [X5H!un upU (dMU"XU 5n XU --n M# [U 5n U nURX5U-nU(aXU 'MgX;dMnX} Mr U$rZ) rr{rHr8rrr4rrGrzr)rrB multinomialsrrr^rr multinomialmultinomial_coeff product_monom product_coeffrrrs r7r4PolyElement._pow_multinomials/D 1=CCE ))33YY))  yy$$yy~~.: *K&M-M'*;'>#^e3$3M#$NM!CZ/M(? -(E!EHHU)E1E#U K#/;& r9c&URnURnURn[UR 55nUR RnUR n[[U55H;nXGnXn [U5H!n XJn U"X5n U"X5XU --X,'M# M= URS5nURnUR5HupU"X5n U"X5US--X+'M UR5 U$)zsquare of a polynomial Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> p = x + y**2 >>> p.square() x**2 + 2*x*y**2 + y**4 r) r8rrrBrr4rrr{imul_numrHru)rr8r-rrrrrk1pkjk2rrorps r7r3PolyElement.squaresyy IIeeDIIK {{(( s4y!ABB1XW"2*S""X+5" JJqMeeJJLDAa#BMAqD(AE! r9cURnU(d [S5e[XR5(aUR U5$[U[ 5(a[UR [5(a%UR RUR:XaOd[URR [5(a5URR RU:XaURU5$[$URU5nURU5URU54$![a [s$f=fNpolynomial division)r8ZeroDivisionErrorr[rrrlr4r __rdivmod__rr quo_ground rem_groundr ryrzr8s r7 __divmod__PolyElement.__divmod__sww#$9: : JJ ' '66":  K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[~~b))%% :$BMM"%r}}R'89 9 "! ! "sD;;E Ec[$rZrrxs r7rLPolyElement.__rdivmod__(r9cURnU(d [S5e[XR5(aUR U5$[U[ 5(a[UR [5(a%UR RUR:XaOd[URR [5(a5URR RU:XaURU5$[$URU5nURU5$![a [s$f=frI) r8rKr[rremrlr4r__rmod__rrrNr rOs r7__mod__PolyElement.__mod__+sww#$9: : JJ ' '66":  K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[{{2&%% %$B==$ $ "! ! "sD**D=<D=c[$rZrSrxs r7rXPolyElement.__rmod__ArUr9cURnU(d [S5e[XR5(a)UR(aXS--$UR U5$[U[ 5(a[UR[5(a%URRUR:XaOd[URR[5(a5URRRU:XaURU5$[$URU5nURU5$![a [s$f=f)NrJr )r8rKr[rrquorlr4r __rtruediv__rrrMr rOs r7 __truediv__PolyElement.__truediv__Dsww#$9: : JJ ' '~~8}$vvbz! K ( ($++~664;;;K;Krww;VBGGNNN;;@S@SW[@[r**%% %$B==$ $ "! ! "s EEEc[$rZrSrxs r7r_PolyElement.__rtruediv__]rUr9c^^^URRmURRnURmURRmUR (a UUU4SjnU$UUU4SjnU$)NcR>Uup#UupEUT :XaUnOT"X$5nUb UT"X554$grZrX a_lm_a_lc b_lm_b_lca_lma_lcb_lmb_lcr domain_quorrs r7term_div'PolyElement._term_div..term_divls@& & 2: E(4E$ *T"888r9cd>Uup#UupEUT :XaUnOT"X$5nUbX5-(d UT"X554$grZrXrfs r7rnroxsC& & 2: E(4E  *T"888r9)r8rr4r^rri)rr4rnrmrrs @@@r7 _term_divPolyElement._term_divesX YY ! !!!ZZ yy-- ?? 0 r9c4URnSn[U[5(aSnU/n[U5(d [ S5eU(d-U(aUR UR 4$/UR 4$UHnURU:wdM[ S5e [U5n[U5Vs/sHobR PM nnUR5nUR n UR5n UV s/sHoR5PM n n U(aSnSn Xe:ayU S:XasUR5nU "XU4XXX45nUb6UunnXvRUU45Xv'URXUU*45nSn OUS- nXe:aU S:XaMsU (d'UR5nU RXU45n X U(aMWUR:XaX- n U(aU(dUR U 4$USU 4$Xy4$s snfs sn f)aDivision algorithm, see [CLO] p64. fv array of polynomials return qv, r such that self = sum(fv[i]*qv[i]) + r All polynomials are required not to be Laurent polynomials. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> f = x**3 >>> f0 = x - y**2 >>> f1 = x - y >>> qv, r = f.div((f0, f1)) >>> qv[0] x**2 + x*y**2 + y**4 >>> qv[1] 0 >>> r y**6 FTrJz"self and f must have the same ringrr)r8r[rlrerKrrr{rrrqr _iadd_monom_iadd_poly_monomr)rfvr8 ret_singleryr_rqvr-rrnfxexpvs divoccurredrtermexpv1rSs r7rPolyElement.divs8yy b+ & &JB2ww#$9: :yy$))++499}$Avv~ !EFF G!&q *Aii * IIK II>>#-/0Rr"R0AK%K1,~~'w%(BE%(O1LM##HE1E--uaj9BE**2551"+>A"#KFA%K1,(MM44/2G!a" 4?? " FA yy!|#!uax5L=+1s 4H;HcUn[U[5(aU/n[U5(d [S5eURnUR nUR nURnUR nUR5nURn UR5nURn U(aUHzn U"XR5n U cMU upU R5H.unnU"X5nU "UU5UU-- nU(dUU M)UUU'M0 UR5nUbUUU4n O= U unnUU;aUU==U- ss'OUUU'UU UR5nUbUUU4n U(aMU$rI)r[rlrerKr8r4rrrqLTrrrUr)rGryr8r4rrryrnltfrgtqrRrSmgcgm1c1ltmltcs r7rWPolyElement.remsq  a % %A1vv#$9: :vv{{(( II;;=dd FFHeec44(>DA"#++-B)"0 T]QrT1! !"$&AbE #0..*C!1S6k"S!8cFcMF AcFcFnn&?qv+C5a8r9c*URU5S$Nr)r)ryrs r7r^PolyElement.quosuuQx{r9cPURU5up#U(dU$[X5erZ)rr")ryrqrys r7exquoPolyElement.exquos$uuQxH%a+ +r9cXRR;aUR5nOUnUup4URU5nUcXBU'U$XT- nU(aXRU'U$X# U$)aadd to self the monomial coeff*x0**i0*x1**i1*... unless self is a generator -- then just return the sum of the two. mc is a tuple, (monom, coeff), where monomial is (i0, i1, ...) Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> p = x**4 + 2*y >>> m = (1, 2) >>> p1 = p._iadd_monom((m, 5)) >>> p1 x**4 + 5*x*y**2 + 2*y >>> p1 is p True >>> p = x >>> p1 = p._iadd_monom((m, 5)) >>> p1 5*x*y**2 + x >>> p1 is p False )r8rrr)rmccpselfrrrSs r7rtPolyElement._iadd_monom sr8 99&& &YY[FF  JJt  9 4L JA t  L r9cbUnX3RR;aUR5nUupEURnURRR nURR nUR5H)upU"X5n U"X5X--n U (aXU 'M'X; M+ U$)aadd to self the product of (p)*(coeff*x0**i0*x1**i1*...) unless self is a generator -- then just return the sum of the two. mc is a tuple, (monom, coeff), where monomial is (i0, i1, ...) Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y, z = ring('x, y, z', ZZ) >>> p1 = x**4 + 2*y >>> p2 = y + z >>> m = (1, 2, 3) >>> p1 = p1._iadd_poly_monom(p2, (m, 3)) >>> p1 x**4 + 3*x*y**3*z**3 + 3*x*y**2*z**4 + 2*y )r8rrrr4rrrH) rrzrryrRrSrrrrorpkars r7ruPolyElement._iadd_poly_monom6s* "" "Bffww~~""ww++ HHJDAa#BMAC'E2F  r9c^URRU5mU(d[$TS:ag[U4SjUR 555$)zx The leading degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3,># UH oTv M g7frZrXr^rrs r7r`%PolyElement.degree..i<^EQx^)r8r rrxrryxrs @r7degreePolyElement.degree[? FFLLOK U7166<<' 'S$sALLN';"<=> >r9c^URRU5mU(d[$TS:ag[U4SjUR 555$)zu The tail degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3,># UH oTv M g7frZrXrs r7r`*PolyElement.tail_degree..rr)r8r rminrrs @r7 tail_degreePolyElement.tail_degreewrr9c U(d[4URR-$[[ [ [ [UR56555$)zx A tuple containing tail degrees in all variables. Note that the degree of 0 is negative infinity (``float('-inf')``) ) rr8rrzrCrrBrGrrs r7 tail_degreesPolyElement.tail_degreesrr9cHU(aURRU5$g)a Leading monomial tuple according to the monomial ordering. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y, z = ring('x, y, z', ZZ) >>> p = x**4 + x**3*y + x**2*z**2 + z**7 >>> p.leading_expv() (4, 0, 0) N)r8rrs r7rPolyElement.leading_expvs 99))$/ /r9c`URXRRR5$rZ)rr8r4rrrs r7 _get_coeffPolyElement._get_coeffs!xxii..3344r9cUS:Xa%URURR5$[XRR5(ac[ UR 55n[U5S:Xa;USup4X@RRR:XaURU5$[SU-5e)a| Returns the coefficient that stands next to the given monomial. Parameters ========== element : PolyElement (with ``is_monomial = True``) or 1 Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y, z = ring("x,y,z", ZZ) >>> f = 3*x**2*y - x*y*z + 7*z**3 + 23 >>> f.coeff(x**2*y) 3 >>> f.coeff(x*y) 0 >>> f.coeff(1) 23 rrzexpected a monomial, got %s) rr8rr[rrBrUr{r4rr)rrr^rrs r7rPolyElement.coeffs4 a<??499#7#78 8  1 1**,-E5zQ$Qx II,,000??5116@AAr9cLURURR5$)z"Returns the constant coefficient. )rr8rrs r7rPolyElement.conststyy3344r9c@URUR55$rZ)rrrs r7rPolyElement.LCst00233r9cXUR5nUcURR$U$rZ)rr8rrs r7LMPolyElement.LMs*  " <99'' 'Kr9cURRnUR5nU(a"URRRX'U$)z Leading monomial as a polynomial element. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> (3*x*y + y**2).leading_monom() x*y )r8rrr4rrr-rs r7 leading_monomPolyElement.leading_monoms> IINN  " ii&&**AGr9cUR5nUc6URRURRR4$XR U54$rZ)rr8rr4rrrs r7rPolyElement.LTsL  " <II(($))*:*:*?*?@ @//$/0 0r9cdURRnUR5nUbXX'U$)zLeading term as a polynomial element. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> (3*x*y + y**2).leading_term() 3*x*y )r8rrrs r7 leading_termPolyElement.leading_terms3 IINN  "  jAGr9c^TcURRmO[R"T5mT[La [ USSS9$[ UU4SjSS9$)Nc US$rrX)rs r7rr%PolyElement._sorted..sqr9T)rwreversec>T"US5$rrX)rr5s r7rrrs uQxr9)r8r5r~r}rsorted)rrWr5s `r7_sortedPolyElement._sortedsL =IIOOE''.E C<##94H H##@$O Or9cZURU5VVs/sHup#UPM snn$s snnf)aOrdered list of polynomial coefficients. Parameters ========== order : :class:`~.MonomialOrder` or coercible, optional Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex, grlex >>> _, x, y = ring("x, y", ZZ, lex) >>> f = x*y**7 + 2*x**2*y**3 >>> f.coeffs() [2, 1] >>> f.coeffs(grlex) [1, 2] r^)rr5_rs r7rOPolyElement.coeffss)0(,zz%'8:'881'8:::'cZURU5VVs/sHup#UPM snn$s snnf)aOrdered list of polynomial monomials. Parameters ========== order : :class:`~.MonomialOrder` or coercible, optional Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex, grlex >>> _, x, y = ring("x, y", ZZ, lex) >>> f = x*y**7 + 2*x**2*y**3 >>> f.monoms() [(2, 3), (1, 7)] >>> f.monoms(grlex) [(1, 7), (2, 3)] r)rr5rrs r7monomsPolyElement.monoms5s)0(,zz%'8:'885'8:::rcTUR[UR55U5$)aOrdered list of polynomial terms. Parameters ========== order : :class:`~.MonomialOrder` or coercible, optional Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> from sympy.polys.orderings import lex, grlex >>> _, x, y = ring("x, y", ZZ, lex) >>> f = x*y**7 + 2*x**2*y**3 >>> f.terms() [((2, 3), 2), ((1, 7), 1)] >>> f.terms(grlex) [((1, 7), 1), ((2, 3), 2)] )rrBrH)rr5s r7r^PolyElement.termsOs 0||D.66r9c4[UR55$)z,Iterator over coefficients of a polynomial. )iterrErs r7 itercoeffsPolyElement.itercoeffsiDKKM""r9c4[UR55$)z)Iterator over monomials of a polynomial. )rrrs r7rPolyElement.itermonomsmDIIK  r9c4[UR55$)z%Iterator over terms of a polynomial. )rrHrs r7rUPolyElement.itertermsqDJJL!!r9c4[UR55$)z+Unordered list of polynomial coefficients. )rBrErs r7 listcoeffsPolyElement.listcoeffsurr9c4[UR55$)z(Unordered list of polynomial monomials. )rBrrs r7 listmonomsPolyElement.listmonomsyrr9c4[UR55$)z$Unordered list of polynomial terms. rtrs r7 listtermsPolyElement.listterms}rr9cXRR;aX-$U(dUR5 gUHnX==U-ss'M U$)amultiply inplace the polynomial p by an element in the coefficient ring, provided p is not one of the generators; else multiply not inplace Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring('x, y', ZZ) >>> p = x + y**2 >>> p1 = p.imul_num(3) >>> p1 3*x + 3*y**2 >>> p1 is p True >>> p = x >>> p1 = p.imul_num(3) >>> p1 3*x >>> p1 is p False N)r8rclear)r-rSrs r7rBPolyElement.imul_numsD4   3J GGI C FaKFr9cURRnURnURnUR 5H nU"X$5nM U$)z*Returns GCD of polynomial's coefficients. )r8r4rrr)ryr4contrrs r7rPolyElement.contentsB{{jj\\^Et#D$ r9cFUR5nXRU54$)z,Returns content and a primitive polynomial. )rrM)ryrs r7 primitivePolyElement.primitivesyy{\\$'''r9cJU(dU$URUR5$)z5Divides all coefficients by the leading coefficient. )rMrrs r7monicPolyElement.monicsH<<% %r9cU(dURR$UR5VVs/sH up#X#U-4PM nnnURU5$s snnfrZ)r8rrUrO)ryrrrr^s r7rPolyElement.mul_groundsJ66;; 78{{}F}|u5'"}FuuU|GsAcURRnUR5VVs/sHup4U"X15U4PM nnnURU5$s snnfrZ)r8rrHrO)ryrrf_monomf_coeffr^s r7 mul_monomPolyElement.mul_monomsQvv** RSRYRYR[]R[>Ng</9R[]uuU|^sAc\Uup#U(aU(dURR$X RR:XaURU5$URRnUR 5VVs/sHupVU"XR5Xc-4PM nnnUR U5$s snnfrZ)r8rrrrrHrO)ryr}rrrrrr^s r7mul_termPolyElement.mul_terms 66;;  ff'' '<<& &vv** XYX_X_XacXaDTG</?XacuuU|ds<B(c URRnU(d [S5eU(aXR:XaU$UR(a8UR nUR 5VVs/sHupEXC"XQ54PM nnnO3UR 5VVs/sHupEXQ-(aMXEU-4PM nnnURU5$s snnfs snnfrI)r8r4rKrrir^rUrO)ryrr4r^rrr^s r7rMPolyElement.quo_grounds#$9: :AOH ??**CABPuc%m,EPE>?kkm`mleTYT])uqj)mE`uuU| Q`s1CC0 CcUup#U(d [S5eU(dURR$X RR:XaUR U5$UR 5nUR 5Vs/sH oT"XQ5PM nnURUVs/sH oUcMUPM sn5$s snfs snfrI)rKr8rrrMrqrUrO)ryr}rrrntr^s r7quo_termPolyElement.quo_terms #$9: :66;;  ff'' '<<& &;;=-.[[]<](1#]<uu%:%Qq%:;;=:sB9"B>,B>cjURRR(a>/nUR5H'up4XA-nXAS-:aXA- nUR X445 M) O(UR5VVs/sH up4X4U-4PM nnnUR U5nUR 5 U$s snnf)Nr)r8r4is_ZZrUrrOru)ryr-r^rrrs r7 trunc_groundPolyElement.trunc_grounds 66==  E !  6>!IE e^, !.>?[[]L]\Uuai(]ELuuU|  Ms7B/cUnUR5nUR5nURRRX45nUR U5nUR U5nXRU4$rZ)rr8r4rrM)rrryfcgcrs r7extract_groundPolyElement.extract_grounds[  YY[ YY[ffmm' LL  LL qyr9cU(d URRR$URRRnU"UR 5Vs/sH o2"U5PM sn5$s snfrZ)r8r4rabsr)ry norm_func ground_absrs r7_normPolyElement._normsT66==%% %**JallnNnUz%0nNO ONsA4c,UR[5$rZ)rrxrs r7max_normPolyElement.max_normwws|r9c,UR[5$rZ)rrDrs r7l1_normPolyElement.l1_normrr9c\URnU/[U5-nS/UR-nUH>nUR5H'n[ U5Hupx[ XGU5XG'M M) M@ [ U5HupyU (aMSXG'M [ U5n[SU55(aXC4$/n UHgnURn UR5H3up[X5VVs/sH up~X~-PM nnnX[ U5'M5 U RU 5 Mi XJ4$s snnf)Nrrc3*# UH oS:Hv M g7frrX)r^rqs r7r`&PolyElement.deflate..0s!q!Avqs) r8rBrrrrrzrerrUrGr)ryrr8rTJr-rrrRrqHhIrrENs r7deflatePolyElement.deflatesvvd1g  C NA%e,DAa=AD-( aLDA1! !H !q! ! !8O A AKKM),Q4af4#%( * HHQKt 5s,D( cURRnUR5H3up4[X15VVs/sH upVXV-PM nnnXB[ U5'M5 U$s snnfrZ)r8rrUrGrz)ryr&rr)rrrEr*s r7inflatePolyElement.inflate@sTvv{{ HA"%a)-)$!!#)A-"qN& .sA cfUnURRnUR(d5UR5upBUR5upQUR XE5nX!-R UR U55nUR(dURW5$UR5$rZ) r8r4rirrr^rrr)rrryr4rrrSr(s r7rPolyElement.lcmIs| KKMEBKKMEB 2"A SIIaeeAh <<? "779 r9c*URU5S$r) cofactorsryrs r7rPolyElement.gcdYs{{1~a  r9c"U(d!U(dURRnX"U4$U(dURU5up4nX4U4$U(dURU5up5nX4U4$[U5S:XaUR U5up4nX4U4$[U5S:XaUR U5up5nX4U4$UR U5unupUR U5up4nURU5URU5URU54$r)r8r _gcd_zeror{ _gcd_monomr+_gcdr.)ryrrr(cffcfgr&s r7r3PolyElement.cofactors\s66;;Dt# #++a.KAC3; ++a.KAC3;  Vq[,,q/KAC3;  Vq[,,q/KAC3; IIaL 6AffQi  ! ckk!nckk!n==r9cURRURRp2UR(aXU4$U*X2*4$rZ)r8rrr)ryrrrs r7r7PolyElement._gcd_zerors:FFJJ T  C< 2tT> !r9c 2URnURRnURRnURnUR n[ UR55SupxXxpUR5HupU"X5n U"X5n M URX4/5n URU"Xy5U"X54/5nURUR5V V s/sHupU"X5U"X54PM sn n 5nXU4$s sn n fr) r8r4rr^rrrBrUrO)ryrr8 ground_gcd ground_quorrmfcf_mgcd_cgcdrrr(r:r;s r7r8PolyElement._gcd_monomysvv[[__ [[__ (( ** akkm$Q'ukkmFB +Eu)E$ EEE>" #eemB. 20EFGHeeUVU`U`UbcUb62mB. 20EFUbcds{ds+D cURnURR(aURU5$URR(aUR U5$UR X5$rZ)r8r4is_QQ_gcd_QQr_gcd_ZZ dmp_inner_gcd)ryrr8s r7r9PolyElement._gcdsRvv ;;  99Q<  [[  99Q< %%a+ +r9c[X5$rZrr4s r7rJPolyElement._gcd_ZZs a|r9cdUnURnURURR5S9nUR 5upRUR 5upaUR U5nUR U5nUR U5upxn UR U5nURUR5pzUR U5RURRX55nU R U5RURRX55n XxU 4$)Nr) r8rr4rkrqr_rJrrrr^) rrryr8r]rCrr(r:r;rSs r7rIPolyElement._gcd_QQs vv::T[[%9%9%;:<   JJx  JJx iil  JJt ttQWWY1ll4 ++DKKOOA,BCll4 ++DKKOOA,BCs{r9c@UnURnU(d X#R4$URnUR(aUR(dUR U5upVnOUR UR5S9nUR5upUR5upURU5nURU5nUR U5upVnURR X5upZn URU5nURU5nURU 5nURU 5nUR5n XR:XaXgpvXg4$XR*:XaU*U*pvXg4$URU 5nURU 5nXg4$)z Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> (2*x**2 - 2).cancel(x**2 - 2*x + 1) (2*x + 2, x - 1) r) r8rr4rirjr3rrkrqr_rcanonical_unit) rrryr8r4rr-rr]cqcpus r7cancelPolyElement.cancelsf vvhh; F$9$9kk!nGA!zz):z;HNN$EBNN$EB 8$A 8$Akk!nGA! 11"9IA2 4 A 4 A R A R A     ?qt ::+ 2rq t  QA QAt r9cdURRnURUR5$rZ)r8r4rRr)ryr4s r7rRPolyElement.canonical_units$$$QTT**r9cURnURU5nURU5nURnUR 5H9upgXc(dMUR Xd5nUR XvU-5XX'M; U$)zComputes partial derivative in ``x``. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> _, x, y = ring("x,y", ZZ) >>> p = x + x**2*y**3 >>> p.diff(x) 2*x*y**3 + 1 )r8r rrrUrr) ryrr8rrRrrres r7diffPolyElement.diffsyvv JJqM    " II;;=KDww&&t/u!W}5)r9c,S[U5s=:aURR::a;O O8UR[ [ URR U555$[SURR<S[U5<35e)Nrz expected at least 1 and at most z values, got )r{r8revaluaterBrGr2r)ryrEs r7rJPolyElement.__call__ sb s6{ *affll *::d3qvv{{F#;<= =TUTZTZT`T`beflbmno or9cUn[U[5(abUc_USUSSsupBnURXB5nU(dU$UVVs/sHupRURU5U4PM nnnURU5$URnUR U5nUR RU5nURS:Xa<UR RnUR5HuupXX)--- nM U$URU5Rn UR5HFupXU SUXS-S-pXU --n X;aXU -n U (aXU 'M5X M9U (dMBXU 'MH U $s snnf)Nrr) r[rBr_rr8r r4rrrrU) rrrpryXYr8rresultrBrrrs r7r_PolyElement.evaluate sg  a  19!aeIFQA 1 A3461!qvvay!n16zz!}$vv JJqM KK   " ::?[[%%F {{} *$ -M99Q<$$D !  8U2AYst%<5d =!K/E&+U  Ku&+U !.KA7sE5cnUn[U[5(a!UcUHupBURXB5nM U$URnUR U5nUR R U5nURS:XaKUR RnUR5HuupXyX(--- nM URU5$URn UR5HIupXU SUS-XS-S-pXU--n X;aXU -n U (aXU 'M8X M<U (dMEXU 'MK U $)Nrrm) r[rBsubsr8r r4rrrrUr) rrrpryrbr8rrdrBrrrs r7rgPolyElement.subs2 s'  a  19FF1LHvv JJqM KK   " ::?[[%%F {{} *$ -??6* *99D !  8U2AY%5cd %C5d =!K/E&+U  Ku&+U !.Kr9c^^^UR5nURnURnU(dXR/4$[ U5Vs/sHoBR US-5PM snm0mUU4Sjn[ [ US- 55n[ [ USS55nURnU(aSupn [UR55HMunumn [U4SjU55(dM%[S[UT555n X:dMHU TU pn MO U S:waXsmn OO~/n[TTSSS -5HunnURUU- 5 M XR[U5U 5- nU n[U5HupCUU"XC5-nM UU-nU(aM[ [URT55nXU4$s snf) a Rewrite *self* in terms of elementary symmetric polynomials. Explanation =========== If this :py:class:`~.PolyElement` belongs to a ring of $n$ variables, we can try to write it as a function of the elementary symmetric polynomials on $n$ variables. We compute a symmetric part, and a remainder for any part we were not able to symmetrize. Examples ======== >>> from sympy.polys.rings import ring >>> from sympy.polys.domains import ZZ >>> R, x, y = ring("x,y", ZZ) >>> f = x**2 + y**2 >>> f.symmetrize() (x**2 - 2*y, 0, [(x, x + y), (y, x*y)]) >>> f = x**2 - y**2 >>> f.symmetrize() (x**2 - 2*y, -2*y**2, [(x, x + y), (y, x*y)]) Returns ======= Triple ``(p, r, m)`` ``p`` is a :py:class:`~.PolyElement` that represents our attempt to express *self* as a function of elementary symmetric polynomials. Each variable in ``p`` stands for one of the elementary symmetric polynomials. The correspondence is given by ``m``. ``r`` is the remainder. ``m`` is a list of pairs, giving the mapping from variables in ``p`` to elementary symmetric polynomials. The triple satisfies the equation ``p.compose(m) + r == self``. If the remainder ``r`` is zero, *self* is symmetric. If it is nonzero, we were not able to represent *self* as symmetric. See Also ======== sympy.polys.polyfuncs.symmetrize References ========== .. [1] Lauer, E. Algorithms for symmetrical polynomials, Proc. 1976 ACM Symp. on Symbolic and Algebraic Computing, NY 242-247. https://dl.acm.org/doi/pdf/10.1145/800205.806342 rc6>X4T;a TUU-TX4'TX4$rZrX)rrB poly_powersrTs r7get_poly_power.PolyElement.symmetrize..get_poly_power s.v[(&+Ahk QF#v& &r9rr )r NNc3@># UHnTUTUS-:v M g7frrX)r^rrs r7r`)PolyElement.symmetrize.. s"AAuQx5Q</rAc3.# UH upX-v M g7frZrX)r^rBrRs r7r`ro s E1D1DsNrm)rr8rrrrCrBrr^rerxrGrrrzr2)rryr8rBrrlrweights symmetric_height_monom_coeffrheight exponentsrm2productrrrkrTs @@@r7 symmetrizePolyElement.symmetrizeY sv IIKvv JJii# #388<8a$$QqS)8<  ' uQU|$uQ2'II &4 #GV%.qwwy%9!>E5AAAA EWe1D EEF'28% &:"}% uIeU12Y%56B  b)7 uY'7? ?IG!),>!//- LA1a4s499e,-W$$S=sGc^ URnURn[[UR[ UR 555m UbX4/nO^[U[5(a [U5nO=[U[5(a[UR5U 4SjS9nO [S5e[U5H unupT UURU54XV'M" UR5H`up[U5nURn UHupXSsoU 'U (dMXU --n M U R![#U5U 45n XJ- nMb U$)Nc>TUS$rrX)rogens_maps r7rr%PolyElement.compose.. s x!~r9rvz9expected a generator, value pair a sequence of such pairsr)r8rrFrGr2rrr[rBrrHrrrrUrrrz)ryrrpr8r replacementsrorrrsubpolyrrBr~s @r7r9PolyElement.compose s+vvyyDIIuTZZ'89: =F8L!T""#Aw At$$%aggi5MN  !\]]"<0IAv'{DMM!,<=LO1KKMLEKEhhG$#h 81!tOG% &&e e'<=G OD* r9cUnURRU5nUR5VVs/sHupVXTU:XdMXV4PM nnnU(dURR$[ U6upUVs/sHoUSUS-XTS-S-PM nnURR [ [ X555$s snnfs snf)am Coefficient of ``self`` with respect to ``x**deg``. Treating ``self`` as a univariate polynomial in ``x`` this finds the coefficient of ``x**deg`` as a polynomial in the other generators. Parameters ========== x : generator or generator index The generator or generator index to compute the expression for. deg : int The degree of the monomial to compute the expression for. Returns ======= :py:class:`~.PolyElement` The coefficient of ``x**deg`` as a polynomial in the same ring. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x, y, z = ring("x, y, z", ZZ) >>> p = 2*x**4 + 3*y**4 + 10*z**2 + 10*x*z**2 >>> deg = 2 >>> p.coeff_wrt(2, deg) # Using the generator index 10*x + 10 >>> p.coeff_wrt(z, deg) # Using the generator 10*x + 10 >>> p.coeff(z**2) # shows the difference between coeff and coeff_wrt 10 See Also ======== coeff, coeffs Nrmr)r8r rUrrGrIrF) rrdegr-rrRrSr^rrOs r7 coeff_wrtPolyElement.coeff_wrt sT  FFLLO$%KKMAMDAQTS[!MA66;; e4:;FqBQ%$,q56*F;vvS%8 9::B >> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2 >>> f.prem(g) # first generator is chosen by default if it is not given -4*y + 4 >>> f.rem(g) # shows the differnce between prem and rem x**2 + x*y >>> f.prem(g, y) # generator is given 0 >>> f.prem(g, 1) # generator index is given 0 See Also ======== pdiv, pquo, pexquo, sympy.polys.domains.ring.Ring.rem rrJrr8r rrKrr2)rrrrydfdgrydrr*lc_gxplc_rrERrrSs r7premPolyElement.prem sl  FFLLO XXa[ XXa[ 6#$9: :2 7H GaK{{1! VV[[^;;q%D7AEqA25 AA!Bw Iu r9cUnURRU5nURU5nURU5nUS:a [S5eX#UpnXE:aXg4$XE- S-n UR X%5n URR Un UR X(5n X- U S- pXj-nXX---nXz-nX-X--nUU- nURU5nX:aOMQX-nUU-nUU-nXg4$)a Computes the pseudo-division of the polynomial ``self`` with respect to ``g``. The pseudo-division algorithm is used to find the pseudo-quotient ``q`` and pseudo-remainder ``r`` such that ``m*f = g*q + r``, where ``m`` represents the multiplier and ``f`` is the dividend polynomial. The pseudo-quotient ``q`` and pseudo-remainder ``r`` are polynomials in the variable ``x``, with the degree of ``r`` with respect to ``x`` being strictly less than the degree of ``g`` with respect to ``x``. The multiplier ``m`` is defined as ``LC(g, x) ^ (deg(f, x) - deg(g, x) + 1)``, where ``LC(g, x)`` represents the leading coefficient of ``g``. It is important to note that in the context of the ``prem`` method, multivariate polynomials in a ring, such as ``R[x,y,z]``, are treated as univariate polynomials with coefficients that are polynomials, such as ``R[x,y][z]``. When dividing ``f`` by ``g`` with respect to the variable ``z``, the pseudo-quotient ``q`` and pseudo-remainder ``r`` satisfy ``m*f = g*q + r``, where ``deg(r, z) < deg(g, z)`` and ``m = LC(g, z)^(deg(f, z) - deg(g, z) + 1)``. In this function, the pseudo-remainder ``r`` can be obtained using the ``prem`` method, the pseudo-quotient ``q`` can be obtained using the ``pquo`` method, and the function ``pdiv`` itself returns a tuple ``(q, r)``. Parameters ========== g : :py:class:`~.PolyElement` The polynomial to divide ``self`` by. x : generator or generator index, optional The main variable of the polynomials and default is first generator. Returns ======= :py:class:`~.PolyElement` The pseudo-division polynomial (tuple of ``q`` and ``r``). Raises ====== ZeroDivisionError : If ``g`` is the zero polynomial. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2 >>> f.pdiv(g) # first generator is chosen by default if it is not given (2*x + 2*y - 2, -4*y + 4) >>> f.div(g) # shows the difference between pdiv and div (0, x**2 + x*y) >>> f.pdiv(g, y) # generator is given (2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0) >>> f.pdiv(g, 1) # generator index is given (2*x**3 + 2*x**2*y + 6*x**2 + 2*x*y + 8*x + 4, 0) See Also ======== prem Computes only the pseudo-remainder more efficiently than `f.pdiv(g)[1]`. pquo Returns only the pseudo-quotient. pexquo Returns only an exact pseudo-quotient having no remainder. div Returns quotient and remainder of f and g polynomials. rrJrr)rrrryrrrryrr*rrrrEQrrrSs r7pdivPolyElement.pdivv s`  FFLLO XXa[ XXa[ 6#$9: :b 74K GaK{{1! VV[[^;;q%D7AEqA25L AA25 AAA!Bw%( G E Et r9c.UnURX5S$)a Polynomial pseudo-quotient in multivariate polynomial ring. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2*y >>> h = 2*x + 2 >>> f.pquo(g) 2*x >>> f.quo(g) # shows the difference between pquo and quo 0 >>> f.pquo(h) 2*x + 2*y - 2 >>> f.quo(h) # shows the difference between pquo and quo 0 See Also ======== prem, pdiv, pexquo, sympy.polys.domains.ring.Ring.quo r)r)rrrrys r7pquoPolyElement.pquo s6 vva|Ar9chUnURX5upEUR(aU$[X15e)a; Polynomial exact pseudo-quotient in multivariate polynomial ring. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x,y = ring("x,y", ZZ) >>> f = x**2 + x*y >>> g = 2*x + 2*y >>> h = 2*x + 2 >>> f.pexquo(g) 2*x >>> f.exquo(g) # shows the differnce between pexquo and exquo Traceback (most recent call last): ... ExactQuotientFailed: 2*x + 2*y does not divide x**2 + x*y >>> f.pexquo(h) Traceback (most recent call last): ... ExactQuotientFailed: 2*x + 2 does not divide x**2 + x*y See Also ======== prem, pdiv, pquo, sympy.polys.domains.ring.Ring.exquo )rrr")rrrryrrys r7pexquoPolyElement.pexquo s/: vva| 99H%a+ +r9cUnURRU5nURU5nURU5nXE:aXpXTpTUS:XaSS/$US:XaUS/$X1/nXE- nSUS--nURX5n X-n UR X%5n X-n SU /n U *n U (aU RU5n UR U 5 XXU - 4up1pWU *X--nURX5n U R U5n UR X-5n US:aU *U-nXS- -nUR U5n OU *n U R U *5 U (aMU$)a Computes the subresultant PRS of two polynomials ``self`` and ``g``. Parameters ========== g : :py:class:`~.PolyElement` The second polynomial. x : generator or generator index The variable with respect to which the subresultant sequence is computed. Returns ======= R : list Returns a list polynomials representing the subresultant PRS. Examples ======== >>> from sympy.polys import ring, ZZ >>> R, x, y = ring("x, y", ZZ) >>> f = x**2*y + x*y >>> g = x + y >>> f.subresultants(g) # first generator is chosen by default if not given [x**2*y + x*y, x + y, y**3 - y**2] >>> f.subresultants(g, 0) # generator index is given [x**2*y + x*y, x + y, y**3 - y**2] >>> f.subresultants(g, y) # generator is given [x**2*y + x*y, x + y, x**3 + x**2] rrr )r8r rrrrr)rrrryrBrRrdrqr(lcrSSror-rs r7 subresultantsPolyElement.subresultants7 siD  FFLLO HHQK HHQK 5qq 6q6M 6q6M F E QUO FF1L E[[  G F B A HHQKqa%JA!af Aq A AQ"B1uSQJa%LGGAJC HHaRL'a*r9c8URRX5$rZ)r8dmp_half_gcdexr4s r7 half_gcdexPolyElement.half_gcdex svv$$Q**r9c8URRX5$rZ)r8 dmp_gcdexr4s r7gcdexPolyElement.gcdex vv%%r9c8URRX5$rZ)r8 dmp_resultantr4s r7 resultantPolyElement.resultant svv##A))r9c8URRU5$rZ)r8dmp_discriminantrs r7 discriminantPolyElement.discriminant svv&&q))r9cURR(aURRU5$[S5e)Nzpolynomial decomposition)r8r# dup_decomposer#rs r7 decomposePolyElement.decompose s0 66  66''* *-.HI Ir9cURR(aURRX5$[S5e)Nzshift: use shift_list instead)r8r# dup_shiftr#ryrps r7shiftPolyElement.shift s0 66  66##A) )-.MN Nr9c8URRX5$rZ)r8 dmp_shiftrs r7 shift_listPolyElement.shift_list rr9cURR(aURRU5$[S5e)Nzsturm sequence)r8r# dup_sturmr#rs r7sturmPolyElement.sturm s0 66  66##A& &-.>? ?r9c8URRU5$rZ)r8 dmp_gff_listrs r7gff_listPolyElement.gff_list vv""1%%r9c8URRU5$rZ)r8dmp_normrs r7normPolyElement.norm svvq!!r9c8URRU5$rZ)r8 dmp_sqf_normrs r7sqf_normPolyElement.sqf_norm rr9c8URRU5$rZ)r8 dmp_sqf_partrs r7sqf_partPolyElement.sqf_part rr9c4URRXS9$)N)re)r8 dmp_sqf_list)ryres r7sqf_listPolyElement.sqf_list svv""1"..r9c8URRU5$rZ)r8dmp_factor_listrs r7 factor_listPolyElement.factor_list svv%%a((r9rrZ)F)rrErFrGrHrOrRrrrrr_rcrbrqrurrrrrrrrrrrrr3rrr\rIrrrrrrrrrrrrrrrr rrrrrr!r r,r&r6r5r4r3rPrLrYrXr`r_ __floordiv__ __rfloordiv__rqrrWr^rrtrurrrrrrrrrrrrrrrOrr^rrrUrrrrBrrrrrrrMr rrNrrrr!r+r.rrr3r7r8r9rJrIrVrRr\rJr_rgrzr9rrrrrrrrrrrrrrrrrrrrrKrXr9r7rlrl<sF?$%3 E 8> =M" 44G0)"  2*>"H.`++MM==55558888**11@@@@## ++ GG R4l(4l60d:.(` :"H:,%,%2L MBJX+Z,*X#J= ?= ?(5#BJ544*11( P;4;474#!"#!"!F ( &  <$J PB !>," ,*6p+2p *X%Nk%Z@3;jYv||<#,JXz+&**J O &@ &"&&/)r9rlN)QrH __future__rtypingroperatorrrrrr r functoolsr typesr sympy.core.exprr sympy.core.intfuncrsympy.core.symbolrrrdsympy.core.sympifyrrsympy.ntheory.multinomialrsympy.polys.compatibilityrsympy.polys.constructorrsympy.polys.densebasicrrr!sympy.polys.domains.domainelementr"sympy.polys.domains.polynomialringrsympy.polys.heuristicgcdrsympy.polys.monomialsrsympy.polys.orderingsrsympy.polys.polyerrorsr r!r"r#sympy.polys.polyoptionsr$r|r%r~r&sympy.polys.polyutilsr'r(r)sympy.printing.defaultsr*sympy.utilitiesr+r,sympy.utilities.iterablesr-sympy.utilities.magicr.r8r;r?rUrgrh__annotations__r1rFrlrXr9r7rs"-- #93>,4CC;=+-%66GG==3+1) #!!<!$<!$<22h @! ^ uup I&)-+tI&)r9