a kh@P@sdZddlmZddlmZmZmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZddlmZdd lmZmZdd lmZmZdd lmZdd lmZdd lm Z ddl!m"Z"m#Z#m$Z$ddl%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6ddl7m&Z8m9Z:m;Z;ddlZ>m?Z?ddl@mAZAddlBmCZCmDZDddlEmFZFddlGmHZHeCe0fddddZIeCe0fd d!ZJeCe0fd"d#ZKeCd$d%ZLd&d'ZMGd(d)d)eAeZNGd*d+d+e(eAeeOZPd,S)-zSparse polynomial rings. ) annotations)addmulltlegtge)reduce) GeneratorType)cacheit)Expr)igcd)Symbolsymbols) CantSympifysympify)multinomial_coefficients)IPolys)construct_domain)ninf dmp_to_dict dmp_from_dict)Domain) DomainElementPolynomialRingheugcd) MonomialOps)lex MonomialOrder)CoercionFailedGeneratorsErrorExactQuotientFailedMultivariatePolynomialError)rOrder build_options)expr_from_dict _dict_reorder_parallel_dict_from_expr)DefaultPrinting)publicsubsets) is_sequence)pollutezMonomialOrder | strordercCst|||}|f|jS)aConstruct 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(_) PolyRinggensrdomainr0_ringr7?/var/www/auris/lib/python3.9/site-packages/sympy/polys/rings.pyring$s r9cCst|||}||jfS)aConstruct 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(_) r1r4r7r7r8xringCs r:cCs(t|||}tdd|jD|j|S)aConstruct 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(_) cSsg|] }|jqSr7)name).0symr7r7r8 ~zvring..)r2r.rr3r4r7r7r8vringbs r@c sd}t|s|gd}}ttt|}t||}t||\}}|jdurtdd|Dg}t||d\|_}t t ||fdd|D}t |j |j|j }tt|j|} |r|| dfS|| fSdS) adConstruct 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(_) FTNcSsg|]}t|qSr7listvaluesr<repr7r7r8r>r?zsring..)optcs"g|]}fdd|DqS)csi|]\}}||qSr7r7r<mcZ coeff_mapr7r8 r?z$sring...)itemsrDrJr7r8r>r?r)r-rBmaprr&r)r5sumrdictzipr2r3r0 from_dict) exprsroptionssinglerFZrepscoeffsZ coeffs_domr6polysr7rJr8srings     rWcCsrt|tr|rt|ddSdSt|tr.|fSt|rftdd|DrPt|Stdd|Drf|StddS)NT)seqr7css|]}t|tVqdSN) isinstancestrr<sr7r7r8 r?z!_parse_symbols..css|]}t|tVqdSrY)rZr r\r7r7r8r^r?zbexpected a string, Symbol or expression or a non-empty sequence of strings, Symbols or expressions)rZr[_symbolsr r-allr"rr7r7r8_parse_symbolss  rbc@s~eZdZUdZded<ded<ded<ded <d ed <efd d ZddZddZddZ ddZ ddZ ddZ dUddZ eddZdd Zed!d"Zed#d$Zd%d&ZdVd'd(Zd)d*Zd+d,Zd-d.ZeZdWd/d0ZdXd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$edEdFZ%edGdHZ&dIdJZ'dKdLZ(dMdNZ)dOdPZ*dQdRZ+dSdTZ,dS)Yr2z*Multivariate distributed polynomial ring. ztuple[PolyElement, ...]r3ztuple[Expr, ...]rintngensrr5r r0c stt|}t|}t|}t|j|||f}|jrXt|t|j @rXt dt |}||_ t||_||_ ||_||_|_t|dj|_d||_||_t|j|_|j|jfg|_|rt|}||_||_ |!|_"|#|_$|%|_&|'|_(|)|_*n6dd}||_||_ dd|_"||_$||_&||_(||_*t+urft,|_-nfdd|_-t.|j |jD]4\} } t/| t0r| j1} t2|| st3|| | q|S)Nz7polynomial ring and it's ground domain share generatorsr7rcSsdSNr7r7)abr7r7r8r?z"PolyRing.__new__..cSsdSrfr7)rgrhrIr7r7r8rir?cs t|dS)Nkey)maxfr/r7r8rir?)4tuplerblen DomainOpt preprocessOrderOpt__name__ is_Compositesetrr"object__new__ _hash_tuplehash_hashrdr5r0 PolyElementnewdtype zero_monom_gensr3 _gens_setone_onerr monomial_mulpow monomial_powZmulpowmonomial_mulpowZldiv monomial_ldivdiv monomial_divlcmZ monomial_lcmgcd monomial_gcdrrl leading_expvrPrZrr;hasattrsetattr) clsrr5r0rdryobjZcodegenZmonunitsymbol generatorr;r7r/r8rxsZ                   zPolyRing.__new__cCsF|jj}g}t|jD]&}||}|j}|||<||qt|S)z(Return a list of polynomial generators. )r5rrangerdmonomial_basiszeroappendro)selfrriexpvpolyr7r7r8r s  zPolyRing._genscCs|j|j|jfSrY)rr5r0rr7r7r8__getnewargs__szPolyRing.__getnewargs__cCs.|j}|d=|D]}|dr||=q|S)NrZ monomial_)__dict__copy startswith)rstaterkr7r7r8 __getstate__s   zPolyRing.__getstate__cCs|jSrY)r{rr7r7r8__hash__#szPolyRing.__hash__cCs2t|to0|j|j|j|jf|j|j|j|jfkSrY)rZr2rr5rdr0rotherr7r7r8__eq__&s  zPolyRing.__eq__cCs ||k SrYr7rr7r7r8__ne__+szPolyRing.__ne__NcCs(|durt|trt|}||||SrY)rZrBro_clonerrr5r0r7r7r8clone.szPolyRing.clonecCs ||p |j|p|j|p|jSrY) __class__rr5r0rr7r7r8r4szPolyRing._clonecCsdg|j}d||<t|S)zReturn the ith-basis element. r)rdro)rrZbasisr7r7r8r8s zPolyRing.monomial_basiscCs |gSrY)r~rr7r7r8r>sz PolyRing.zerocCs ||jSrY)r~rrr7r7r8rBsz PolyRing.onecCst|to|j|kS)zATrue if ``element`` is an element of this ring. False otherwise. )rZr|r9relementr7r7r8 is_elementFszPolyRing.is_elementcCs|j||SrY)r5convertrr orig_domainr7r7r8 domain_newJszPolyRing.domain_newcCs||j|SrY)term_newr)rcoeffr7r7r8 ground_newMszPolyRing.ground_newcCs ||}|j}|r|||<|SrY)rr)rmonomrrr7r7r8rPs  zPolyRing.term_newcCst|trF||jkr|St|jtr<|jj|jkr<||Stdn|t|trZtdnht|trn| |St|t rz | |WSt y| |YS0nt|tr||S||SdS)N conversionZparsing)rZr|r9r5rrNotImplementedErrorr[rOrQrB from_terms ValueError from_listr from_exprrr7r7r8ring_newWs$             zPolyRing.ring_newcCs8|j}|j}|D]\}}|||}|r|||<q|SrY)rrrL)rrrrrrrr7r7r8rQos  zPolyRing.from_dictcCs|t||SrY)rQrOrr7r7r8rzszPolyRing.from_termscCs|t||jd|jSNr)rQrrdr5rr7r7r8r}szPolyRing.from_listcs$jfddt|S)Ncs|}|dur|S|jr2tttt|jS|jrNtttt|jS| \}}|j rx|dkrx|t |S  |SdSr)getZis_Addr rrBrMargsZis_MulrZ as_base_expZ is_Integerrcrr)exprrbaseexp_rebuildr5mappingrr7r8rs  z(PolyRing._rebuild_expr.._rebuild)r5r)rrrr7rr8 _rebuild_exprszPolyRing._rebuild_exprcCsXttt|j|j}z|||}Wn"tyHtd||fYn 0||SdS)Nz@expected an expression convertible to a polynomial in %s, got %s) rOrBrPrr3rr!rr)rrrrr7r7r8rs  zPolyRing.from_exprcCs|dur|jrd}qd}nt|trj|}d|kr<||jkrr?z!PolyRing.drop..raN)rvrMr enumeraterr5rrr3rr7rr8drops z PolyRing.dropcCs$|j|}|s|jS|j|dSdS)Nra)rr5r)rrkrr7r7r8 __getitem__s zPolyRing.__getitem__cCs6|jjst|jdr$|j|jjdStd|jdS)Nr5r5z%s is not a composite domain)r5rurrrrr7r7r8 to_groundszPolyRing.to_groundcCst|SrYrrr7r7r8 to_domainszPolyRing.to_domaincCsddlm}||j|j|jS)Nr) FracField)Zsympy.polys.fieldsrrr5r0)rrr7r7r8to_fields zPolyRing.to_fieldcCst|jdkSrrpr3rr7r7r8 is_univariateszPolyRing.is_univariatecCst|jdkSrrrr7r7r8is_multivariateszPolyRing.is_multivariatecGs8|j}|D](}t|tdr*||j|7}q ||7}q |S)aw 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 rrobjsprr7r7r8rs   z PolyRing.addcGs8|j}|D](}t|tdr*||j|9}q ||9}q |S)a 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 rrr7r7r8rs   z PolyRing.mulcs`tt|j|fddt|jD}fddt|jD}|sH|S|j||j|dSdS)zd Remove specified generators from the ring and inject them into its domain. csg|]\}}|vr|qSr7r7rrr7r8r>$r?z+PolyRing.drop_to_ground..csg|]\}}|vr|qSr7r7)r<rrrr7r8r>%r?rr5N)rvrMrrrr3rrrr7rr8drop_to_grounds zPolyRing.drop_to_groundcCs6||kr.t|jt|j}|jt|dS|SdS)z+Add the generators of ``other`` to ``self``raNrvrunionrrB)rrsymsr7r7r8compose,szPolyRing.composecCs$t|jt|}|jt|dS)z9Add the elements of ``symbols`` as generators to ``self``rar)rrrr7r7r8add_gens4szPolyRing.add_genscs|dks||jkr&td||jfn^|s0|jS|j}tt|jt|D]4tfddt|jD}|| ||j j7}qJ|SdS)zo Return the elementary symmetric polynomial of degree *n* over this ring's generators. rz7Cannot generate symmetric polynomial of order %s for %sc3s|]}t|vVqdSrY)rcr<rr]r7r8r^Er?z*PolyRing.symmetric_poly..N) rdrr3rrr,rrcrorr5)rnrrr7rr8symmetric_poly9szPolyRing.symmetric_poly)NNN)N)N)N)-rt __module__ __qualname____doc____annotations__rrxrrrrrrrr rrpropertyrrrrrrr__call__rQrrrrrrrrrrrrrrrrrrr7r7r7r8r2s`  >            r2cseZdZdZfddZddZddZdd Zd d Zd Z d dZ ddZ ddZ ddZ ddZddZddZddZddZd*dd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Z e!d;d<Z"e!d=d>Z#e!d?d@Z$e!dAdBZ%e!dCdDZ&e!dEdFZ'e!dGdHZ(e!dIdJZ)e!dKdLZ*e!dMdNZ+e!dOdPZ,e!dQdRZ-e!dSdTZ.e!dUdVZ/e!dWdXZ0e!dYdZZ1e!d[d\Z2d]d^Z3d_d`Z4dadbZ5dcddZ6dedfZ7dgdhZ8didjZ9dkdlZ:dmdnZ;dodpZdudvZ?dwdxZ@dydzZAd{d|ZBd}d~ZCddZDddZEddZFddZGddZHddZIddZJddZKddZLddZMd+ddZNddZOd,ddZPddZQddZRddZSddZTddZUe!ddZVe!ddZWddZXe!ddZYddZZddZ[d-ddZ\d.ddZ]d/ddZ^ddZ_ddZ`ddZaddZbddZcddZddd„ZeddĄZfddƄZgddȄZhddʄZidd̄Zjdd΄ZkddЄZldd҄ZmddԄZnenZoddքZpdd؄ZqddڄZrdd܄ZsddބZtddZuddZvddZwddZxddZyddZzddZ{ddZ|ddZ}ddZ~ddZddZddZd0ddZd1ddZddZd2ddZddZd3ddZd4ddZd5ddZd6d d Zd7d d Zd dZddZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd8d&d'Zd(d)ZZS(9r|z5Element of multivariate distributed polynomial ring. cst|||_dSrY)super__init__r9)rr9initrr7r8rMs zPolyElement.__init__cCst|tsJt|jtsJ|jj}t|ts4J|D]@\}}||sRJt||jj ksfJt dd|Ds.) rZr|r9r2r5rrLZof_typerprdr`)rdomrrr7r7r8_checkSszPolyElement._checkcCs||j|SrY)rr9)rrr7r7r8r}]szPolyElement.newcCs |jSrY)r9rrr7r7r8parent`szPolyElement.parentcCs|jt|fSrY)r9rB itertermsrr7r7r8rcszPolyElement.__getnewargs__NcCs.|j}|dur*t|jt|f|_}|SrY)r{rzr9 frozensetrL)rr{r7r7r8rhszPolyElement.__hash__cCs ||S)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 )r}rr7r7r8rsszPolyElement.copycCsZ|j|kr|S|jj|jkrFttt||jj|j}|||jjS|||jjSdSrY)r9rrBrPr(rr5rQ)rnew_ringtermsr7r7r8set_rings  zPolyElement.set_ringcGsJ|s|jj}n(t||jjkr6td|jjt|ft|g|RS)Nz+Wrong number of symbols, expected %s got %s)r9rrprdrr' as_expr_dict)rrr7r7r8as_exprs zPolyElement.as_exprcs |jjjfdd|DS)Ncsi|]\}}||qSr7r7r<rrto_sympyr7r8rKr?z,PolyElement.as_expr_dict..)r9r5rrrr7rr8rs zPolyElement.as_expr_dictcsx|jj}|jr|js|j|fS|}|j|j}|j}|D]}|||q@| fdd| D}|fS)Ncsg|]\}}||fqSr7r7)r<kvcommonr7r8r>r?z,PolyElement.clear_denoms..) r9r5is_Fieldhas_assoc_Ringrget_ringrdenomrCr}rL)rr5Z ground_ringrr rrr7rr8 clear_denomss   zPolyElement.clear_denomscCs$t|D]\}}|s ||=q dS)z+Eliminate monomials with zero coefficient. NrBrL)rrrr7r7r8 strip_zeroszPolyElement.strip_zerocCsH|s | S|j|r"t||St|dkr2dS||jj|kSdS)aPEquality 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 rFN)r9rrOrrprrp1p2r7r7r8rs   zPolyElement.__eq__cCs ||k SrYr7rr7r7r8rszPolyElement.__ne__cCs|j}||r`t|t|kr,dS|jj}|D]}||||||s<dSqszPolyElement.to_densecCst|SrY)rOrr7r7r8to_dictAszPolyElement.to_dictcCs|s||jjjS|d}|d}|j}|j}|j} |j} g} |D]4\} } |j| }|rfdnd}| || | kr|| }|r| dr|dd}n.|r| } | |jjj kr|j | |dd}nd }g}t | D]}| |}|sq|j |||dd}|dkrN|t|ks$|d kr6|j ||d d}n|}| |||fq| d |q|rn|g|}| ||qH| d d vr| d }|dkr| d dd | S)NZMulZAtom -  + -rT)strictrFz%s)r&r%)Z_printr9r5rrrdrr is_negativerrrZ parenthesizerrcjoinpopinsert)rprinter precedenceZ exp_patternZ mul_symbolZprec_mulZ prec_atomr9rrdzmZsexpvsrrnegativesignZscoeffZsexpvrrrZsexpheadr7r7r8r[DsT          zPolyElement.strcCs ||jjvSrY)r9rrr7r7r8 is_generatortszPolyElement.is_generatorcCs| pt|dko|jj|vSr)rpr9rrr7r7r8rxszPolyElement.is_groundcCs| pt|dko|jdkSr)rpLCrr7r7r8 is_monomial|szPolyElement.is_monomialcCs t|dkSr)rprr7r7r8is_termszPolyElement.is_termcCs|jj|jSrY)r9r5r*r5rr7r7r8r*szPolyElement.is_negativecCs|jj|jSrY)r9r5 is_positiver5rr7r7r8r8szPolyElement.is_positivecCs|jj|jSrY)r9r5is_nonnegativer5rr7r7r8r9szPolyElement.is_nonnegativecCs|jj|jSrY)r9r5is_nonpositiver5rr7r7r8r:szPolyElement.is_nonpositivecCs| SrYr7rmr7r7r8is_zeroszPolyElement.is_zerocCs ||jjkSrY)r9rrmr7r7r8is_oneszPolyElement.is_onecCs|jj|jSrY)r9r5r<r5rmr7r7r8is_monicszPolyElement.is_moniccCs|jj|SrY)r9r5r<contentrmr7r7r8 is_primitiveszPolyElement.is_primitivecCstdd|DS)Ncss|]}t|dkVqdSrNrNr<rr7r7r8r^r?z(PolyElement.is_linear..r` itermonomsrmr7r7r8 is_linearszPolyElement.is_linearcCstdd|DS)Ncss|]}t|dkVqdS)NrArBr7r7r8r^r?z+PolyElement.is_quadratic..rCrmr7r7r8 is_quadraticszPolyElement.is_quadraticcCs|jjs dS|j|SNT)r9rdZ dmp_sqf_prmr7r7r8 is_squarefreeszPolyElement.is_squarefreecCs|jjs dS|j|SrH)r9rdZdmp_irreducible_prmr7r7r8is_irreducibleszPolyElement.is_irreduciblecCs |jjr|j|StddS)Nzcyclotomic polynomial)r9rZdup_cyclotomic_pr$rmr7r7r8 is_cyclotomics zPolyElement.is_cyclotomiccCs|dd|DS)NcSsg|]\}}|| fqSr7r7rr7r7r8r>r?z'PolyElement.__neg__..)r}rrr7r7r8__neg__szPolyElement.__neg__cCs|SrYr7rr7r7r8__pos__szPolyElement.__pos__c Cs>|s |S|j}||rj|}|j}|jj}|D]*\}}||||}|r^|||<q:||=q:|St|trt|jt r|jj|jkrn*t|jjt r|jjj|kr| |St Sz| |}Wnt yt YS0|}|s|S|j} | |vr||| <n(|||  kr&|| =n|| |7<|SdS)aAdd 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 N)rr9rrr5rrLrZr|r__radd__rrr!rr) rrr9rrrrrZcp2r0r7r7r8__add__sB       zPolyElement.__add__cCs|}|s|S|j}z||}Wnty:tYS0|j}||vrX|||<n&||| krn||=n|||7<|SdSrY)rr9rr!rrr)rrrr9r0r7r7r8rNs    zPolyElement.__radd__c Cs6|s |S|j}||rj|}|j}|jj}|D]*\}}||||}|r^|||<q:||=q:|St|trt|jt r|jj|jkrn*t|jjt r|jjj|kr| |St Sz| |}Wnt yt YS0|}|j}||vr| ||<n&|||kr||=n|||8<|SdS)a.Subtract 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 N)rr9rrr5rrLrZr|r__rsub__rrr!rr) rrr9rrrrrr0r7r7r8__sub__s>       zPolyElement.__sub__cCsZ|j}z||}Wnty*tYS0|j}|D]}|| ||<q6||7}|SdS)a#n - 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 N)r9rr!rr)rrr9rrr7r7r8rPEs  zPolyElement.__rsub__cCs8|j}|j}|r|s|S||r|j}|jj}|j}t|}|D]6\}} |D](\} } ||| } || || | || <qVqJ||St |t rt |jt r|jj|jkrn*t |jjt r|jjj|kr| |St Sz||}Wntyt YS0|D] \}} | |} | r| ||<q|SdS)a!Multiply 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 N)r9rrrr5rrBrLr rZr|r__rmul__rrr!)rrr9rrrrZp2itexp1v1Zexp2Zv2rrr7r7r8__mul__as<        zPolyElement.__mul__cCsf|jj}|s|Sz|j|}Wnty6tYS0|D]\}}||}|r@|||<q@|SdS)ap2 * 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 N)r9rrr!rrL)rrrrSrTrr7r7r8rRs   zPolyElement.__rmul__cCst|tstd|n|dkr,td||j}|sJ|r@|jStdn\t|dkrt|d\}}|j }||j jkr||| ||<n|||| ||<|St|}|dkrtdnV|dkr| S|dkr| S|dkr|| St|d kr ||S||Sd S) a(raise 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 z#exponent must be an integer, got %srz/exponent must be a non-negative integer, got %sz0**0rzNegative exponentrFN)rZrc TypeErrorrr9rrprBrLrr5rrsquare_pow_multinomial _pow_generic)rrr9rrrr7r7r8__pow__s8        zPolyElement.__pow__cCs@|jj}|}|d@r*||}|d8}|s*q<|}|d}q |S)NrrF)r9rrY)rrrrIr7r7r8r[s zPolyElement._pow_genericcCstt||}|jj}|jj}|}|jjj}|jj}|D]|\}} |} | } t||D](\} \} }| rZ|| | | } | || 9} qZt | } | }| | ||}|r||| <q@| |vr@|| =q@|SrY) rrprLr9rrr5rrPror)rrZ multinomialsrrrrrZ multinomialZmultinomial_coeffZ product_monomZ product_coeffrrrr7r7r8rZs*    zPolyElement._pow_multinomialcCs|j}|j}|j}t|}|jj}|j}tt|D]N}||}||} t|D]0} || } ||| } || || || || <qTq8| d}|j}| D](\} }|| | } || ||d|| <q| |S)asquare 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 rF) r9rrrBrr5rrrpimul_numrLr )rr9rrrrrrZk1pkjZk2rrrr7r7r8rYs(     zPolyElement.squarecCs|j}|stdnd||r(||St|trxt|jtrN|jj|jkrNn*t|jjtrt|jjj|krt||St Sz| |}Wnt yt YS0| || |fSdSNpolynomial division)r9ZeroDivisionErrorrrrZr|r5r __rdivmod__rrr! quo_ground rem_groundrrr9r7r7r8 __divmod__:s        zPolyElement.__divmod__cCs:|j}z||}Wnty*tYS0||SdSrY)r9rr!rrrfr7r7r8rcPs   zPolyElement.__rdivmod__cCs|j}|stdnd||r(||St|trxt|jtrN|jj|jkrNn*t|jjtrt|jjj|krt||St Sz| |}Wnt yt YS0| |SdSr`) r9rbrremrZr|r5r__rmod__rrr!rerfr7r7r8__mod__Ys        zPolyElement.__mod__cCs:|j}z||}Wnty*tYS0||SdSrY)r9rr!rrhrfr7r7r8rios   zPolyElement.__rmod__cCs|j}|stdnd||r(||St|trxt|jtrN|jj|jkrNn*t|jjtrt|jjj|krt||St Sz| |}Wnt yt YS0| |SdSr`) r9rbrquorZr|r5r __rtruediv__rrr!rdrfr7r7r8 __floordiv__xs        zPolyElement.__floordiv__cCs:|j}z||}Wnty*tYS0||SdSrY)r9rr!rrkrfr7r7r8 __rfloordiv__s   zPolyElement.__rfloordiv__cCs|j}|stdnd||r(||St|trxt|jtrN|jj|jkrNn*t|jjtrt|jjj|krt||St Sz| |}Wnt yt YS0| |SdSr`) r9rbrexquorZr|r5rrlrrr!rdrfr7r7r8 __truediv__s        zPolyElement.__truediv__cCs:|j}z||}Wnty*tYS0||SdSrY)r9rr!rrorfr7r7r8rls   zPolyElement.__rtruediv__csJ|jj|jj}|j|jj|jr6fdd}nfdd}|S)NcsF|\}}|\}}|kr|}n ||}|dur>|||fSdSdSrYr7Z a_lm_a_lcZ b_lm_b_lcZa_lmZa_lcZb_lmZb_lcrZ domain_quorr0r7r8term_divs z'PolyElement._term_div..term_divcsN|\}}|\}}|kr|}n ||}|dusF||sF|||fSdSdSrYr7rqrrr7r8rss )r9rr5rkrr)rr5rsr7rrr8 _term_divs  zPolyElement._term_divcs|jd}t|trd}|g}t|s.td|sL|rBjjfSgjfS|D]}|jkrPtdqPt|}fddt|D}| }j}| }dd|D} |rnd} d} | |krH| dkrH| } || || f| | || | | f} | d ur>| \}}||  ||f|| <| || || f}d } q| d 7} q| s| } | | || f}|| =q| jkr||7}|r|sj|fS|d|fSn||fSd S) aUDivision 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 FTraz"self and f must have the same ringcsg|] }jqSr7)rrr9r7r8r>r?z#PolyElement.div..cSsg|] }|qSr7)r)r<Zfxr7r7r8r>r?rNr)r9rZr|r`rbrrrprrrtr _iadd_monom_iadd_poly_monomr)rZfvZ ret_singlernr]ZqvrrrsZexpvsrZ divoccurredrtermZexpv1rIr7rur8rsV     &    zPolyElement.divcCs@|}t|tr|g}t|s$td|j}|j}|j}|j}|j}|}|j } | }|j } |r<|D]} || | j } | durh| \} }| D]8\}}||| }| ||||}|s||=q|||<q| }|dur|||f} q^qh| \}}||vr|||7<n|||<||=| }|dur^|||f} q^|Sr`)rZr|r`rbr9r5rrrtLTrrrr)rGrnr9r5rrrxrsZltfrgZtqrHrImgcgm1Zc1ZltmZltcr7r7r8rh#sL      zPolyElement.remcCs||dSNr)r)rnr{r7r7r8rkPszPolyElement.quocCs$||\}}|s|St||dSrY)rr#)rnr{qrxr7r7r8roSszPolyElement.exquocCs^||jjvr|}n|}|\}}||}|dur>|||<n||7}|rT|||<n||=|S)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 N)r9rrr)rmcZcpselfrrrIr7r7r8rv[s     zPolyElement._iadd_monomc Cs~|}||jjvr|}|\}}|j}|jjj}|jj}|D]8\} } || |} || || |} | rr| || <q@|| =q@|S)aEadd 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 )r9rrrr5rrrL) rrrrrHrIrrrrrkarr7r7r8rws    zPolyElement._iadd_poly_monomcs>|j||stSdkr dStfdd|DSdS)z The leading degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3s|]}|VqdSrYr7rBrr7r8r^r?z%PolyElement.degree..N)r9rrrlrDrnxr7rr8degrees  zPolyElement.degreecCs0|stf|jjSttttt|SdS)z A tuple containing leading degrees in all variables. Note that the degree of 0 is negative infinity (``float('-inf')``) N) rr9rdrorMrlrBrPrDrmr7r7r8degreesszPolyElement.degreescs>|j||stSdkr dStfdd|DSdS)z The tail degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3s|]}|VqdSrYr7rBrr7r8r^r?z*PolyElement.tail_degree..N)r9rrminrDrr7rr8 tail_degrees  zPolyElement.tail_degreecCs0|stf|jjSttttt|SdS)z A tuple containing tail degrees in all variables. Note that the degree of 0 is negative infinity (``float('-inf')``) N) rr9rdrorMrrBrPrDrmr7r7r8 tail_degreesszPolyElement.tail_degreescCs|r|j|SdSdS)aTLeading 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)r9rrr7r7r8rs zPolyElement.leading_expvcCs|||jjjSrY)rr9r5rrrr7r7r8 _get_coeffszPolyElement._get_coeffcCsn|dkr||jjS|j|r^t|}t|dkr^|d\}}||jjjkr^||St d|dS)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 %sN) rr9rrrBrrpr5rr)rrrrrr7r7r8rs     zPolyElement.coeffcCs||jjS)z"Returns the constant coefficient. )rr9rrr7r7r8r szPolyElement.constcCs||SrY)rrrr7r7r8r5$szPolyElement.LCcCs |}|dur|jjS|SdSrY)rr9rrr7r7r8LM(szPolyElement.LMcCs&|jj}|}|r"|jjj||<|S)a 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 )r9rrr5rrrrr7r7r8 leading_monom0s zPolyElement.leading_monomcCs4|}|dur"|jj|jjjfS|||fSdSrY)rr9rr5rrrr7r7r8rzEszPolyElement.LTcCs(|jj}|}|dur$||||<|S)aLeading 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 N)r9rrrr7r7r8 leading_termMs  zPolyElement.leading_termcsPdur|jjn ttur6t|ddddSt|fddddSdS)NcSs|dSrr7rr7r7r8rihr?z%PolyElement._sorted..T)rkreversecs |dSrr7rr/r7r8rijr?)r9r0rsrrrsorted)rrXr0r7r/r8_sortedas   zPolyElement._sortedcCsdd||DS)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] cSsg|] \}}|qSr7r7)r<_rr7r7r8r>r?z&PolyElement.coeffs..rrr0r7r7r8rUlszPolyElement.coeffscCsdd||DS)a Ordered 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)] cSsg|] \}}|qSr7r7)r<rrr7r7r8r>r?z&PolyElement.monoms..rrr7r7r8monomsszPolyElement.monomscCs|t||S)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)] )rrBrLrr7r7r8rszPolyElement.termscCs t|S)z,Iterator over coefficients of a polynomial. )iterrCrr7r7r8 itercoeffsszPolyElement.itercoeffscCs t|S)z)Iterator over monomials of a polynomial. )rrrr7r7r8rDszPolyElement.itermonomscCs t|S)z%Iterator over terms of a polynomial. )rrLrr7r7r8rszPolyElement.itertermscCs t|S)z+Unordered list of polynomial coefficients. rArr7r7r8 listcoeffsszPolyElement.listcoeffscCs t|S)z(Unordered list of polynomial monomials. )rBrrr7r7r8 listmonomsszPolyElement.listmonomscCs t|S)z$Unordered list of polynomial terms. r rr7r7r8 listtermsszPolyElement.listtermscCsB||jjvr||S|s$|dS|D]}|||9<q(|S)a:multiply 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)r9rclear)rrIrr7r7r8r]s zPolyElement.imul_numcCs0|jj}|j}|j}|D]}|||}q|S)z*Returns GCD of polynomial's coefficients. )r9r5rrr)rnr5contrrr7r7r8r>s   zPolyElement.contentcCs,|}||jjjkr||fS|||fS)z,Returns content and a primitive polynomial. )r>r9r5rrd)rnrr7r7r8 primitiveszPolyElement.primitivecCs|s|S||jSdS)z5Divides all coefficients by the leading coefficient. N)rdr5rmr7r7r8monicszPolyElement.moniccs,s |jjSfdd|D}||S)Ncsg|]\}}||fqSr7r7rrr7r8r>r?z*PolyElement.mul_ground..)r9rrr})rnrrr7rr8r!szPolyElement.mul_groundcs*|jjfdd|D}||S)Ncsg|]\}}||fqSr7r7r<Zf_monomZf_coeffrrr7r8r>r?z)PolyElement.mul_monom..)r9rrLr})rnrrr7rr8 mul_monomszPolyElement.mul_monomcsZ|\|rs|jjS|jjkr.|S|jjfdd|D}||S)Ncs"g|]\}}||fqSr7r7rrrrr7r8r>#r?z(PolyElement.mul_term..)r9rrr!rrLr})rnryrr7rr8mul_terms  zPolyElement.mul_termcsl|jj}std|r"|jkr&|S|jrL|jfdd|D}nfdd|D}||S)Nracsg|]\}}||fqSr7r7rrkrr7r8r>0r?z*PolyElement.quo_ground..cs$g|]\}}|s||fqSr7r7rrr7r8r>2r?)r9r5rbrrrkrr})rnrr5rr7rr8rd&szPolyElement.quo_groundcsl\}}|stdn"|s"|jjS||jjkr8||S|fdd|D}|dd|DS)Nracsg|]}|qSr7r7r<tryrsr7r8r>Br?z(PolyElement.quo_term..cSsg|]}|dur|qSrYr7rr7r7r8r>Cr?)rbr9rrrdrtrr})rnryrrrr7rr8quo_term6s   zPolyElement.quo_termcsx|jjjrLg}|D]2\}}|}|dkr:|}|||fqnfdd|D}||}||S)NrFcsg|]\}}||fqSr7r7rrr7r8r>Qr?z,PolyElement.trunc_ground..)r9r5is_ZZrrr}r )rnrrrrrr7rr8 trunc_groundEs   zPolyElement.trunc_groundcCsB|}|}|}|jj||}||}||}|||fSrY)r>r9r5rrd)rr|rnfcgcrr7r7r8extract_groundYs  zPolyElement.extract_groundcs6|s|jjjS|jjj|fdd|DSdS)Ncsg|] }|qSr7r7)r<rZ ground_absr7r8r>jr?z%PolyElement._norm..)r9r5rabsr)rnZ norm_funcr7rr8_normes  zPolyElement._normcCs |tSrY)rrlrmr7r7r8max_normlszPolyElement.max_normcCs |tSrY)rrNrmr7r7r8l1_normoszPolyElement.l1_normcGs|j}|gt|}dg|j}|D]6}|D](}t|D]\}}t|||||<q.cSsg|]\}}||qSr7r7r<rr_r7r7r8r>r?z'PolyElement.deflate..) r9rBrdrDrr ror`rrrPr)rnr{r9rVJrrrrHrhHhIrNr7r7r8deflaters*    zPolyElement.deflatecCs>|jj}|D](\}}ddt||D}||t|<q|S)NcSsg|]\}}||qSr7r7rr7r7r8r>r?z'PolyElement.inflate..)r9rrrPro)rnrrrrrr7r7r8inflates zPolyElement.inflatecCsf|}|jj}|js6|\}}|\}}|||}||||}|jsZ||S|SdSrY) r9r5rrrrkrr!r)rr|rnr5rrrIrr7r7r8rs    zPolyElement.lcmcCs||dSr) cofactorsrnr|r7r7r8rszPolyElement.gcdcCs|s|s|jj}|||fS|s8||\}}}|||fS|sV||\}}}|||fSt|dkr|||\}}}|||fSt|dkr||\}}}|||fS||\}\}}||\}}}||||||fSr)r9r _gcd_zerorp _gcd_monomr_gcdr)rnr|rrcffcfgrr7r7r8rs$       zPolyElement.cofactorscCs4|jj|jj}}|jr"|||fS| || fSdSrY)r9rrr9)rnr|rrr7r7r8rs zPolyElement._gcd_zeroc s|j}|jj}|jj|j}|jt|d\}}|||D]\}}||||qH|fg} |||fg} |fdd|D} | | | fS)Nrcs$g|]\}}||fqSr7r7)r<r}r~Z_cgcdZ_mgcdZ ground_quorr7r8r>r?z*PolyElement._gcd_monom..) r9r5rrkrrrBrr}) rnr|r9Z ground_gcdrZmfcfr}r~rrrr7rr8rs   "zPolyElement._gcd_monomcCs:|j}|jjr||S|jjr*||S|||SdSrY)r9r5Zis_QQ_gcd_QQr_gcd_ZZZ dmp_inner_gcd)rnr|r9r7r7r8rs   zPolyElement._gcdcCs t||SrYrrr7r7r8rszPolyElement._gcd_ZZc Cs|}|j}|j|jd}|\}}|\}}||}||}||\}}} ||}|j|} }|| |j | |}| | |j | |} ||| fS)Nr) r9rr5r r rrr5rr!rk) rr|rnr9rrr~rrrrIr7r7r8rs     zPolyElement._gcd_QQc Cs|}|j}|s||jfS|j}|jr*|js<||\}}}n|j|d}|\} }|\} }| |}| |}||\}}}|j| | \}} } | |}| |}| | }| | }| } | |jkrn0| |j kr| | }}n| | }| | }||fS)a 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) r9rr5rrrrr r rr!canonical_unit) rr|rnr9r5rrrrZcqcpur7r7r8cancels4              zPolyElement.cancelcCs|jj}||jSrY)r9r5rr5)rnr5r7r7r8r6 szPolyElement.canonical_unitc Cs`|j}||}||}|j}|D]2\}}||r(|||}||||||<q(|S)a!Computes 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 )r9rrrrrr) rnrr9rrHr|rrer7r7r8diff: s   zPolyElement.diffcGsTdt|kr|jjkr8nn|tt|jj|Std|jjt|fdS)Nrz1expected at least 1 and at most %s values, got %s)rpr9rdevaluaterBrPr3r)rnrCr7r7r8rS s zPolyElement.__call__c sH|}t|tr`|dur`|d|dd\}}||}|sD|Sfdd|D}||S|j}||}|j|}|jdkr|jj}| D]\\}}||||7}q|S| |j} | D]t\} }| || d|| |dd}} |||}| | vr2|| | }|r*|| | <n| | =q|r|| | <q| SdS)Nrrcsg|]\}}||fqSr7)r)r<YrgXr7r8r>c r?z(PolyElement.evaluate..) rZrBrr9rr5rrdrrr) rrrgrnr9rresultrrrrr7rr8rY s8      &     zPolyElement.evaluatec Cs |}t|tr4|dur4|D]\}}|||}q|S|j}||}|j|}|jdkr|jj}| D]\\}} || ||7}qj| |S|j} | D]x\} } | || d|d| |dd}} | ||} | | vr | | | } | r| | | <n| | =q| r| | | <q| SdS)Nrre) rZrBsubsr9rr5rrdrrr) rrrgrnrr9rrrrrrr7r7r8r s2     *     zPolyElement.subscs|}|jj}|s$|jgfSfddt|Difdd}tt|d}tt|dd}j}|rrd\}}} t|D]R\} \} tfd d |Drt d d t |D} | |kr| | }}} q|dkr|| } nqrg} t dd d D]\}}| ||q| t | | 7}| }t| D]\} }||| |9}qN||8}qrtt j}|||fS)aX 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 csg|]}|dqS)r)rrrur7r8r> r?z*PolyElement.symmetrize..cs,||fvr ||||f<||fSrYr7)rr) poly_powersrVr7r8get_poly_power s z.PolyElement.symmetrize..get_poly_powerrrr)rNNc3s"|]}||dkVqdSr@r7rrr7r8r^ r?z)PolyElement.symmetrize..css|]\}}||VqdSrYr7)r<rrHr7r7r8r^ r?Nre)rr9rdrrrBrrr`rlrPrrror3)rrnrrrweightsZ symmetricZ_heightZ_monomZ_coeffrrheightZ exponentsrm2productrr7)rrrVr9r8 symmetrize s>;    zPolyElement.symmetrizec s|j}|j}tt|jt|j|dur6||fg}n@t|trJt|}n,t|trnt | fddd}nt dt |D]"\}\}}|| |f||<q~|D]`\}} t|}|j} |D]*\} }|| d} || <| r| || 9} q| t|| f} || 7}q|S)Ncs |dSrr7)rZgens_mapr7r8ri$ r?z%PolyElement.compose..rjz9expected a generator, value pair a sequence of such pairsr)r9rrOrPr3rrdrZrBrrLrrrrrrro) rnrrgr9r replacementsrr|rrZsubpolyrrr7rr8r s,      zPolyElement.composecsh|}|j|fdd|D}|s4|jjSt|\}}fdd|D}|jtt||S)aU 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 cs$g|]\}}|kr||fqSr7r7rGdegrr7r8r>e r?z)PolyElement.coeff_wrt..cs,g|]$}|dd|ddqS)Nrerr7)r<rHrr7r8r>k r?)r9rrrrPrQrO)rrrrrrrUr7rr8 coeff_wrt9 s*  zPolyElement.coeff_wrtcCs|}|j|}||}||}|dkr4td||}}||krJ|S||d}|||} |jj|} |||} |||d} }|| } || | | }| |}||}||krnqqn| |}||S)a Pseudo-remainder of the polynomial ``self`` with respect to ``g``. The pseudo-quotient ``q`` and pseudo-remainder ``r`` with respect to ``z`` when dividing ``f`` by ``g`` 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)``. See :meth:`pdiv` for explanation of pseudo-division. 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-remainder polynomial. 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.prem(g) # first generator is chosen by default if it is not given -4*y + 4 >>> f.rem(g) # shows the difference 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 rrarr9rrrbrr3)rr|rrndfdgrxdrrlc_gxplc_rr_Rr{rIr7r7r8premn s,6         zPolyElement.premcCs|}|j|}||}||}|dkr4td|||}}}||krT||fS||d} |||} |jj|} |||} ||| d} } || }|| | | }|| }|| | | }||}||}||krxqqx| | }||}||}||fS)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. rrarr)rr|rrnrrrrxrrrrrr_Qrr{rIr7r7r8pdiv s4P        zPolyElement.pdivcCs|}|||dS)aW 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)rr|rrnr7r7r8pquoG szPolyElement.pquocCs,|}|||\}}|jr|St||dS)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 difference 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 N)rr;r#)rr|rrnrrxr7r7r8pexquoe s zPolyElement.pexquocCsX|}|j|}||}||}||kr@||}}||}}|dkrPddgS|dkr`|dgS||g}||}d|d}|||} | |} |||} | |} d| g} | } | rT| |} || || | || f\}}}}| | |}|||} | |} ||| } |dkr@| |}| |d}||} n| } | | q|S)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)r9rrrrrro)rr|rrnrrHrdrhrlcrISrrrr7r7r8 subresultants sF"                 zPolyElement.subresultantscCs|j||SrY)r9Zdmp_half_gcdexrr7r7r8 half_gcdex szPolyElement.half_gcdexcCs|j||SrY)r9Z dmp_gcdexrr7r7r8gcdex szPolyElement.gcdexcCs|j||SrY)r9Z dmp_resultantrr7r7r8 resultant szPolyElement.resultantcCs |j|SrY)r9Zdmp_discriminantrmr7r7r8 discriminant szPolyElement.discriminantcCs |jjr|j|StddS)Nzpolynomial decomposition)r9rZ dup_decomposer$rmr7r7r8 decompose s zPolyElement.decomposecCs"|jjr|j||StddS)Nzshift: use shift_list instead)r9rZ dup_shiftr$rnrgr7r7r8shift szPolyElement.shiftcCs|j||SrY)r9Z dmp_shiftrr7r7r8 shift_list szPolyElement.shift_listcCs |jjr|j|StddS)Nzsturm sequence)r9rZ dup_sturmr$rmr7r7r8sturm s zPolyElement.sturmcCs |j|SrY)r9Z dmp_gff_listrmr7r7r8gff_list szPolyElement.gff_listcCs |j|SrY)r9Zdmp_normrmr7r7r8norm szPolyElement.normcCs |j|SrY)r9Z dmp_sqf_normrmr7r7r8sqf_norm szPolyElement.sqf_normcCs |j|SrY)r9Z dmp_sqf_partrmr7r7r8sqf_part szPolyElement.sqf_partFcCs|jj||dS)N)r`)r9Z dmp_sqf_list)rnr`r7r7r8sqf_list szPolyElement.sqf_listcCs |j|SrY)r9Zdmp_factor_listrmr7r7r8 factor_list szPolyElement.factor_list)N)N)N)N)N)N)N)N)N)N)N)N)N)N)F)rtrrrrrr}rrr{rrrrrr r rrrrrrrrrrrr rr#r$r[rr4rr6r7r*r8r9r:r;r<r=r?rErGrIrJrKrLrMrOrNrQrPrUrRr\r[rZrYrgrcrjrirmrnrprlrtrrhrkrorvrwrrrrrrrrr5rrrzrrrUrrrrDrrrrr]r>rrr!rrrdrrrerrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr __classcell__r7r7rr8r|JsT       0                 6646%    !L-,%   %      #   !  8 , 'm 5[~%]            r|N)Qr __future__roperatorrrrrrr functoolsr typesr Zsympy.core.cacher Zsympy.core.exprr Zsympy.core.intfuncr Zsympy.core.symbolrrr_Zsympy.core.sympifyrrZsympy.ntheory.multinomialrZsympy.polys.compatibilityrZsympy.polys.constructorrZsympy.polys.densebasicrrrZsympy.polys.domains.domainrZ!sympy.polys.domains.domainelementrZ"sympy.polys.domains.polynomialringrZsympy.polys.heuristicgcdrZsympy.polys.monomialsrZsympy.polys.orderingsrr Zsympy.polys.polyerrorsr!r"r#r$Zsympy.polys.polyoptionsrqr%rsr&Zsympy.polys.polyutilsr'r(r)Zsympy.printing.defaultsr*Zsympy.utilitiesr+r,Zsympy.utilities.iterablesr-Zsympy.utilities.magicr.r9r:r@rWrbr2rOr|r7r7r7r8sP                   4