U ZʹjF@sUdZddlmZddlmZddlmZmZmZm Z m Z 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/m0Z0m1Z1m2Z2m3Z3ddl4m5Z6m7Z8m9Z9ddl:m;Z;mm?Z?ddl@mAZAmBZBddlCmDZDddlEmFZFeAe.fddZGeAe.fddZHeAe.fdd ZIeAd!d"ZJd#d$ZKiZLd%eMd&<Gd'd(d(e?eZNGd)d*d*e&e?eeOZPd+S),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)pollutecCst|||}|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(_) PolyRinggensrdomainorder_ringr5P/var/www/html/bwave/python/venv/lib/python3.8/site-packages/sympy/polys/rings.pyring#s r7cCst|||}||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(_) r.r1r5r5r6xringBs r8cCs(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|] }|jqSr5)name).0symr5r5r6 }szvring..)r/r-rr0r1r5r5r6vringas r=c sd}t|s|gd}}ttt|}t||}t||\}}|jdkrtdd|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|qSr5listvaluesr:repr5r5r6r<szsring..)optcs"g|]}fdd|DqS)csi|]\}}||qSr5r5r:mcZ coeff_mapr5r6 sz$sring...)itemsrArGr5r6r<sr)r,r?maprr%r(r2sumrdictzipr/r0r3 from_dict) ZexprsroptionsZsinglerCZrepscoeffsZ coeffs_domr4polysr5rGr6srings     rRcCsrt|tr|rt|ddSdSt|tr.|fSt|rftdd|DrPt|Stdd|Drf|StddS)NT)seqr5css|]}t|tVqdSN) isinstancestrr:sr5r5r6 sz!_parse_symbols..css|]}t|tVqdSrT)rUr rWr5r5r6rYszbexpected a string, Symbol or expression or a non-empty sequence of strings, Symbols or expressions)rUrV_symbolsr r,allr rr5r5r6_parse_symbolss  r]zdict[Any, Any] _ring_cachec@s@eZdZdZefddZddZddZdd Zd d Z d d Z ddZ dGddZ ddZ eddZeddZdHddZddZddZdd ZeZdId!d"ZdJd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Z ed7d8Z!ed9d:Z"d;d<Z#d=d>Z$d?d@Z%dAdBZ&dCdDZ'dEdFZ(dS)Kr/z*Multivariate distributed polynomial ring. c stt|}t|}t|}t|j|||f}t|}|dkr|j rlt |t |j @rlt dt |}||_t||_tdtfd|i|_||_ ||_||_|_d||_||_t |j|_|j|jfg|_|r8t|}||_ |!|_"|#|_$|%|_&|'|_(|)|_*|+|_,n6dd}||_ ||_"dd|_$||_&||_(||_*||_,t-krt.|_/nfdd|_/t0|j |jD]4\} } t1| t2r| j3} t4|| st5|| | q|t|<|S) Nz7polynomial ring and it's ground domain share generators PolyElementr7rcSsdSNr5r5)abr5r5r6z"PolyRing.__new__..cSsdSrar5)rbrcrFr5r5r6rdrecs t|dS)Nkey)maxfr3r5r6rdre)6tupler]len DomainOpt preprocessOrderOpt__name__r^get is_Compositesetrr object__new__ _hash_tuplehash_hashtyper_dtypengensr2r3 zero_monom_gensr0 _gens_setone_onerr monomial_mulpow monomial_powZmulpowmonomial_mulpowZldiv monomial_ldivdiv monomial_divlcmZ monomial_lcmgcd monomial_gcdrrh leading_expvrMrUrr9hasattrsetattr) clsrr2r3r|rwobjZcodegenZmonunitsymbol generatorr9r5rkr6rvs`                     zPolyRing.__new__cCsF|jj}g}t|jD]&}||}|j}|||<||qt|S)z(Return a list of polynomial generators. )r2rranger|monomial_basiszeroappendrl)selfrr~iexpvpolyr5r5r6r~s  zPolyRing._genscCs|j|j|jfSrT)rr2r3rr5r5r6__getnewargs__szPolyRing.__getnewargs__cCs.|j}|d=|D]}|dr||=q|S)NrZ monomial_)__dict__copy startswith)rstatergr5r5r6 __getstate__s   zPolyRing.__getstate__cCs|jSrT)ryrr5r5r6__hash__ szPolyRing.__hash__cCs2t|to0|j|j|j|jf|j|j|j|jfkSrT)rUr/rr2r|r3rotherr5r5r6__eq__#s  zPolyRing.__eq__cCs ||k SrTr5rr5r5r6__ne__(szPolyRing.__ne__NcCs ||p |j|p|j|p|jSrT) __class__rr2r3)rrr2r3r5r5r6clone+szPolyRing.clonecCsdg|j}d||<t|S)zReturn the ith-basis element. r)r|rl)rrZbasisr5r5r6r.s zPolyRing.monomial_basiscCs|SrT)r{rr5r5r6r4sz PolyRing.zerocCs ||jSrT)r{rrr5r5r6r8sz PolyRing.onecCs|j||SrT)r2convertrelement orig_domainr5r5r6 domain_new<szPolyRing.domain_newcCs||j|SrT)term_newr})rcoeffr5r5r6 ground_new?szPolyRing.ground_newcCs ||}|j}|r|||<|SrT)rr)rmonomrrr5r5r6rBs  zPolyRing.term_newcCst|trF||jkr|St|jtr<|jj|jkr<||Stdn~t|trZtdnjt|trn| |St|t rz | |WSt k r| |YSXnt|tr||S||SdS)N conversionZparsing)rUr_r7r2rrNotImplementedErrorrVrLrNr? from_terms ValueError from_listr from_exprrrr5r5r6ring_newIs$            zPolyRing.ring_newcCs8|j}|j}|D]\}}|||}|r|||<q|SrT)rrrI)rrrrrrrr5r5r6rNas  zPolyRing.from_dictcCs|t||SrT)rNrLrr5r5r6rlszPolyRing.from_termscCs|t||jd|jSNr)rNrr|r2rr5r5r6roszPolyRing.from_listcs$jfddt|S)Ncs|}|dk r|S|jr2tttt|jS|jrNtttt|jS| \}}|j rx|dkrx|t |S  |SdSr)rrZis_Addr rr?rJargsZis_MulrZ as_base_expZ is_Integerintrr)exprrbaseexp_rebuildr2mappingrr5r6rus  z(PolyRing._rebuild_expr.._rebuild)r2r)rrrr5rr6 _rebuild_exprrszPolyRing._rebuild_exprcCsZttt|j|j}z|||}Wn$tk rJtd||fYn X||SdS)Nz@expected an expression convertible to a polynomial in %s, got %s) rLr?rMrr0rrrr)rrrrr5r5r6rs zPolyRing.from_exprcCs|dkr|jrd}qd}nt|trj|}d|kr<||jkr.r\N)rtrJr enumeraterr2rrr0rr5rr6drops z PolyRing.dropcCs$|j|}|s|jS|j|dSdS)Nr\)rr2r)rrgrr5r5r6 __getitem__s zPolyRing.__getitem__cCs6|jjst|jdr$|j|jjdStd|jdS)Nr2r2z%s is not a composite domain)r2rsrrrrr5r5r6 to_groundszPolyRing.to_groundcCst|SrTrrr5r5r6 to_domainszPolyRing.to_domaincCsddlm}||j|j|jS)Nr) FracField)Zsympy.polys.fieldsrrr2r3)rrr5r5r6to_fields zPolyRing.to_fieldcCst|jdkSrrmr0rr5r5r6 is_univariateszPolyRing.is_univariatecCst|jdkSrrrr5r5r6is_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 rrZobjsprr5r5r6rs   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 rrr5r5r6rs   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|]\}}|kr|qSr5r5rrr5r6r<sz+PolyRing.drop_to_ground..csg|]\}}|kr|qSr5r5)r:rrrr5r6r<srr2N)rtrJrrrr0rrrr5rr6drop_to_grounds zPolyRing.drop_to_groundcCs6||kr.t|jt|j}|jt|dS|SdS)z+Add the generators of ``other`` to ``self``r\Nrtrunionrr?)rrsymsr5r5r6composeszPolyRing.composecCs$t|jt|}|jt|dS)z9Add the elements of ``symbols`` as generators to ``self``r\r)rrrr5r5r6add_gens&szPolyRing.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|kVqdSrT)rr:rrXr5r6rY7sz*PolyRing.symmetric_poly..N) r|rr0rrr+rrrlrr2)rnrrr5rr6symmetric_poly+szPolyRing.symmetric_poly)NNN)N)N)N))rq __module__ __qualname____doc__rrvr~rrrrrrrpropertyrrrrrr__call__rNrrrrrrrrrrrrrrrrrrr5r5r5r6r/sP A           r/c@sfeZdZdZddZddZddZdZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZd"ddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zed7d8Z ed9d:Z!ed;d<Z"ed=d>Z#ed?d@Z$edAdBZ%edCdDZ&edEdFZ'edGdHZ(edIdJZ)edKdLZ*edMdNZ+edOdPZ,edQdRZ-edSdTZ.edUdVZ/edWdXZ0dYdZZ1d[d\Z2d]d^Z3d_d`Z4dadbZ5dcddZ6dedfZ7dgdhZ8didjZ9dkdlZ:dmdnZ;dodpZdudvZ?dwdxZ@dydzZAd{d|ZBeAZCeBZDd}d~ZEddZFddZGddZHddZIddZJddZKd#ddZLddZMd$ddZNddZOddZPddZQddZRddZSeddZTeddZUddZVeddZWddZXddZYd%ddZZd&ddZ[d'ddZ\ddZ]ddZ^ddZ_ddZ`ddZaddZbddZcddZdddZeddZfdd„ZgddĄZhddƄZiddȄZjddʄZkdd̄ZlelZmdd΄ZnddЄZodd҄ZpddԄZqddքZrdd؄ZsddڄZtdd܄ZuddބZvddZwddZxddZyddZzddZ{ddZ|ddZ}ddZ~ddZd(ddZd)ddZddZd*ddZddZd+ddZd,ddZd-ddZd.ddZd/ddZddZddZd d Zd d Zd dZddZddZddZddZddZddZddZd0ddZd d!ZdS(1r_z5Element of multivariate distributed polynomial ring. cCs ||SrT)r)rinitr5r5r6new?szPolyElement.newcCs |jSrT)r7rrr5r5r6parentBszPolyElement.parentcCs|jt|fSrT)r7r? itertermsrr5r5r6rEszPolyElement.__getnewargs__NcCs.|j}|dkr*t|jt|f|_}|SrT)ryrxr7 frozensetrI)rryr5r5r6rJszPolyElement.__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 )rrr5r5r6rUszPolyElement.copycCsZ|j|kr|S|jj|jkrFttt||jj|j}|||jjS|||jjSdSrT)r7rr?rMr'rr2rN)rnew_ringtermsr5r5r6set_ringqs  zPolyElement.set_ringcGsH|s|jj}n(t||jjkr6td|jjt|ft|f|S)Nz+Wrong number of symbols, expected %s got %s)r7rrmr|rr& as_expr_dict)rrr5r5r6as_exprzs zPolyElement.as_exprcs |jjjfdd|DS)Ncsi|]\}}||qSr5r5r:rrto_sympyr5r6rHsz,PolyElement.as_expr_dict..)r7r2rrrr5rr6rs zPolyElement.as_expr_dictcsx|jj}|jr|js|j|fS|}|j|j}|j}|D]}|||q@| fdd| D}|fS)Ncsg|]\}}||fqSr5r5)r:kvcommonr5r6r<sz,PolyElement.clear_denoms..) r7r2is_Fieldhas_assoc_Ringrget_ringrdenomr@rrI)rr2Z ground_ringrrrrr5rr6 clear_denomss   zPolyElement.clear_denomscCs$t|D]\}}|s ||=q dS)z+Eliminate monomials with zero coefficient. Nr?rI)rrrr5r5r6 strip_zeroszPolyElement.strip_zerocCsR|s | St|tr,|j|jkr,t||St|dkr>> 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)rUr_r7rLrrmrrr}p1p2r5r5r6rs  zPolyElement.__eq__cCs ||k SrTr5rr5r5r6rszPolyElement.__ne__cCs|j}t||jrbt|t|kr.dS|jj}|D]}||||||s>dSq>dSt|dkrrdSz|j|}Wnt k rYdSX|j| ||SdS)z+Approximate equality test for polynomials. FTrN) r7rUr{rtkeysr2almosteqrmrrconst)rrZ tolerancer7rrr5r5r6rs    zPolyElement.almosteqcCst||fSrT)rmrrr5r5r6sort_keyszPolyElement.sort_keycCs(t||jjr |||StSdSrT)rUr7r{r NotImplemented)rropr5r5r6_cmpszPolyElement._cmpcCs ||tSrT)r rrr5r5r6__lt__szPolyElement.__lt__cCs ||tSrT)r rrr5r5r6__le__szPolyElement.__le__cCs ||tSrT)r rrr5r5r6__gt__szPolyElement.__gt__cCs ||tSrT)r r rr5r5r6__ge__szPolyElement.__ge__cCsH|j}||}|jdkr$||jfSt|j}||=||j|dfSdS)Nrr\)r7rr|r2r?rrrrr7rrr5r5r6_drops    zPolyElement._dropcCs||\}}|jjdkr8|jr*|dStd|nP|j}|D]<\}}||dkrvt|}||=||t |<qFtd|qF|SdS)NrzCannot drop %sr) rr7r| is_groundrrrrIr?rl)rrrr7rrrKr5r5r6rs   zPolyElement.dropcCs6|j}||}t|j}||=||j|||dfS)Nr)r7rr?rrrr5r5r6_drop_to_grounds   zPolyElement._drop_to_groundcCs|jjdkrtd||\}}|j}|jjd}|D]b\}}|d|||dd}||kr||||||<q<||||||7<q<|S)Nrz$Cannot drop only generator to groundr) r7r|rrrr2r0r mul_ground)rrrr7rrrmonr5r5r6rs   zPolyElement.drop_to_groundcCst||jjd|jjSr)rr7r|r2rr5r5r6to_dense szPolyElement.to_densecCst|SrT)rLrr5r5r6to_dict#szPolyElement.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 kr| d }|dkr| d dd | S)NZMulZAtom -  + -rT)strictrFz%s)rr)Z_printr7r2rrr|r}r is_negativerrrZ parenthesizerrjoinpopinsert)rprinter precedenceZ exp_patternZ mul_symbolZprec_mulZ prec_atomr7rr|zmZsexpvsrrnegativesignZscoeffZsexpvrrrZsexpheadr5r5r6rV&sT          zPolyElement.strcCs ||jjkSrT)r7rrr5r5r6 is_generatorVszPolyElement.is_generatorcCs| pt|dko|jj|kSr)rmr7r}rr5r5r6rZszPolyElement.is_groundcCs| pt|dko|jdkSr)rmLCrr5r5r6 is_monomial^szPolyElement.is_monomialcCs t|dkSr)rmrr5r5r6is_termbszPolyElement.is_termcCs|jj|jSrT)r7r2rr*rr5r5r6rfszPolyElement.is_negativecCs|jj|jSrT)r7r2 is_positiver*rr5r5r6r-jszPolyElement.is_positivecCs|jj|jSrT)r7r2is_nonnegativer*rr5r5r6r.nszPolyElement.is_nonnegativecCs|jj|jSrT)r7r2is_nonpositiver*rr5r5r6r/rszPolyElement.is_nonpositivecCs| SrTr5rir5r5r6is_zerovszPolyElement.is_zerocCs ||jjkSrT)r7rrir5r5r6is_onezszPolyElement.is_onecCs|jj|jSrT)r7r2r1r*rir5r5r6is_monic~szPolyElement.is_moniccCs|jj|SrT)r7r2r1contentrir5r5r6 is_primitiveszPolyElement.is_primitivecCstdd|DS)Ncss|]}t|dkVqdSrNrKr:rr5r5r6rYsz(PolyElement.is_linear..r[ itermonomsrir5r5r6 is_linearszPolyElement.is_linearcCstdd|DS)Ncss|]}t|dkVqdS)Nr6r7r5r5r6rYsz+PolyElement.is_quadratic..r8rir5r5r6 is_quadraticszPolyElement.is_quadraticcCs|jjs dS|j|SNT)r7r|Z dmp_sqf_prir5r5r6 is_squarefreeszPolyElement.is_squarefreecCs|jjs dS|j|Sr=)r7r|Zdmp_irreducible_prir5r5r6is_irreducibleszPolyElement.is_irreduciblecCs |jjr|j|StddS)Nzcyclotomic polynomial)r7rZdup_cyclotomic_pr"rir5r5r6 is_cyclotomics zPolyElement.is_cyclotomiccCs|dd|DS)NcSsg|]\}}|| fqSr5r5rr5r5r6r<sz'PolyElement.__neg__..)rrrr5r5r6__neg__szPolyElement.__neg__cCs|SrTr5rr5r5r6__pos__szPolyElement.__pos__c CsB|s |S|j}t||jrl|}|j}|jj}|D]*\}}||||}|r`|||<q<||=q<|St|trt|jt r|jj|jkrn*t|jjt r|jjj|kr| |St Sz| |}Wnt k rt YSX|}|s|S|j} | |kr||| <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)rr7rUr{rrr2rrIr_r__radd__r rrr}r) rrr7rrrrrrZcp2r%r5r5r6__add__sB      zPolyElement.__add__cCs|}|s|S|j}z||}Wntk r<tYSX|j}||krZ|||<n&||| krp||=n|||7<|SdSrT)rr7rrr r}r)rrrr7r%r5r5r6rCs   zPolyElement.__radd__c Cs:|s |S|j}t||jrl|}|j}|jj}|D]*\}}||||}|r`|||<q<||=q<|St|trt|jt r|jj|jkrn*t|jjt r|jjj|kr| |St Sz| |}Wnt k rt YSX|}|j}||kr | ||<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)rr7rUr{rrr2rrIr_r__rsub__r rrr}r) rrr7rrrrrrr%r5r5r6__sub__s>      zPolyElement.__sub__cCs\|j}z||}Wntk r,tYSX|j}|D]}|| ||<q8||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)r7rrr r)rrr7rrr5r5r6rE's zPolyElement.__rsub__cCs<|j}|j}|r|s|St||jr|j}|jj}|j}t|}|D]6\}} |D](\} } ||| } || || | || <qXqL| |St|t rt|jt r|jj|jkrn*t|jjt r|jjj|kr| |St Sz||}Wntk rt YSX|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)r7rrUr{rrr2rr?rIrr_r__rmul__r rr)rrr7rrrrrZp2itexp1v1Zexp2Zv2rrr5r5r6__mul__Bs<        zPolyElement.__mul__cCsh|jj}|s|Sz|j|}Wntk r8tYSX|D]\}}||}|rB|||<qB|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)r7rrrr rI)rrrrHrIrr5r5r6rGts  zPolyElement.__rmul__cCs|j}|s|r|jStdn\t|dkrzt|d\}}|j}||jjkrb|||||<n||||||<|St |}|dkrtdnT|dkr| S|dkr| S|dkr|| St|dkr| |S| |SdS) 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 z0**0rrzNegative exponentr;N)r7rrrmr?rIrr2rrrsquare_pow_multinomial _pow_generic)rrr7rrrr5r5r6__pow__s0       zPolyElement.__pow__cCs@|jj}|}|d@r*||}|d8}|s*q<|}|d}q |S)Nrr;)r7rrM)rrrrFr5r5r6rOs zPolyElement._pow_genericcCstt||}|jj}|jj}|}|jjj}|jj}|D]|\}} |} | } t||D](\} \} }| rZ|| | | } | || 9} qZt | } | }| | ||}|r||| <q@| |kr@|| =q@|SrT) rrmrIr7rr}r2rrMrlrr)rrZ multinomialsrr}rrrZ multinomialZmultinomial_coeffZ product_monomZ product_coeffrrrr5r5r6rNs*    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 r;) r7rrrr?rr2rrrmimul_numrIr)rr7rrrrrrrZk1pkjZk2rrrr5r5r6rMs(     zPolyElement.squarecCs|j}|stdnft||jr*||St|trzt|jtrP|jj|jkrPn*t|jjtrv|jjj|krv||St Sz| |}Wnt k rt YSX| || |fSdSNpolynomial division)r7ZeroDivisionErrorrUr{rr_r2r __rdivmod__r rr quo_ground rem_groundrrr7r5r5r6 __divmod__s       zPolyElement.__divmod__cCstSrTr rr5r5r6rW(szPolyElement.__rdivmod__cCs|j}|stdnft||jr*||St|trzt|jtrP|jj|jkrPn*t|jjtrv|jjj|krv||St Sz| |}Wnt k rt YSX| |SdSrT) r7rVrUr{remr_r2r__rmod__r rrrYrZr5r5r6__mod__+s       zPolyElement.__mod__cCstSrTr\rr5r5r6r^AszPolyElement.__rmod__cCs|j}|stdnzt||jr>|jr2||dS||SnPt|trt|jtrd|jj|jkrdn*t|jjtr|jjj|kr| |St Sz| |}Wnt k rt YSX| |SdS)NrUr)r7rVrUr{r+quor_r2r __rtruediv__r rrrXrZr5r5r6 __truediv__Ds$       zPolyElement.__truediv__cCstSrTr\rr5r5r6ra]szPolyElement.__rtruediv__csJ|jj|jj}|j|jj|jr6fdd}nfdd}|S)NcsF|\}}|\}}|kr|}n ||}|dk r>|||fSdSdSrTr5Z a_lm_a_lcZ b_lm_b_lcZa_lmZa_lcZb_lmZb_lcrZ domain_quorr%r5r6term_divls z'PolyElement._term_div..term_divcsN|\}}|\}}|kr|}n ||}|dksF||sF|||fSdSdSrTr5rcrdr5r6rexs )r7r}r2r`rr)rr2rer5rdr6 _term_dives  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 k r>| \}}||  ||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 FTrUz"self and f must have the same ringcsg|] }jqSr5)rrr7r5r6r<sz#PolyElement.div..cSsg|] }|qSr5)r)r:Zfxr5r5r6r<srNr)r7rUr_r[rVrrrmrrrfr _iadd_monom_iadd_poly_monomr})rZfvZ ret_singlerjrXZqvrrreZexpvsrZ divoccurredrtermZexpv1rFr5rgr6rsV     &    zPolyElement.divcCs@|}t|tr|g}t|s$td|j}|j}|j}|j}|j}|}|j } | }|j } |r<|D]} || | j } | dk rh| \} }| D]8\}}||| }| ||||}|s||=q|||<q| }|dk r|||f} q^qh| \}}||kr|||7<n|||<||=| }|dk r^|||f} q^|SrT)rUr_r[rVr7r2rrrfLTrrrrr)rGrjr7r2rrrjreZltfrrgZtqrErFmgcgm1c1ZltmZltcr5r5r6r]sL      zPolyElement.remcCs||dSNr)r)rjrmr5r5r6r`szPolyElement.quocCs$||\}}|s|St||dSrT)rr!)rjrmqrjr5r5r6exquoszPolyElement.exquocCs^||jjkr|}n|}|\}}||}|dkr>|||<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)r7rrrr)rmcZcpselfrrrFr5r5r6rh s     zPolyElement._iadd_monomc Cs~|}||jjkr|}|\}}|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 )r7rrrrr2rrrI) rrrvrrErFrrrrrrkarr5r5r6ri6s    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|]}|VqdSrTr5r7rr5r6rYisz%PolyElement.degree..N)r7rrrhr9rjxr5rxr6degree[s  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) rr7r|rlrJrhr?rMr9rir5r5r6degreeskszPolyElement.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|]}|VqdSrTr5r7rxr5r6rYsz*PolyElement.tail_degree..N)r7rrminr9ryr5rxr6 tail_degreews  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) rr7r|rlrJr}r?rMr9rir5r5r6 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)r7rrr5r5r6rs zPolyElement.leading_expvcCs|||jjjSrT)rrr7r2rrrr5r5r6 _get_coeffszPolyElement._get_coeffcCsp|dkr||jjSt||jjr`t|}t|dkr`|d\}}||jjj kr`||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) rr7r}rUr{r?rrmr2rr)rrrrrr5r5r6rs    zPolyElement.coeffcCs||jjS)z"Returns the constant coefficient. )rr7r}rr5r5r6rszPolyElement.constcCs||SrT)rrrr5r5r6r*szPolyElement.LCcCs |}|dkr|jjS|SdSrT)rr7r}rr5r5r6LMszPolyElement.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 )r7rrr2rrrrr5r5r6 leading_monoms zPolyElement.leading_monomcCs4|}|dkr"|jj|jjjfS|||fSdSrT)rr7r}r2rrrr5r5r6rlszPolyElement.LTcCs(|jj}|}|dk r$||||<|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)r7rrrr5r5r6 leading_terms  zPolyElement.leading_termcsPdkr|jjn ttkr6t|ddddSt|fddddSdS)NcSs|dSrsr5rr5r5r6rdrez%PolyElement._sorted..T)rgreversecs |dSrsr5rrkr5r6rdre)r7r3rprorsorted)rrSr3r5rkr6_sorteds   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|] \}}|qSr5r5)r:_rr5r5r6r<3sz&PolyElement.coeffs..rrr3r5r5r6rPszPolyElement.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|] \}}|qSr5r5)r:rrr5r5r6r<Msz&PolyElement.monoms..rrr5r5r6monoms5szPolyElement.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)] )rr?rIrr5r5r6rOszPolyElement.termscCs t|S)z,Iterator over coefficients of a polynomial. )iterr@rr5r5r6 itercoeffsiszPolyElement.itercoeffscCs t|S)z)Iterator over monomials of a polynomial. )rrrr5r5r6r9mszPolyElement.itermonomscCs t|S)z%Iterator over terms of a polynomial. )rrIrr5r5r6rqszPolyElement.itertermscCs t|S)z+Unordered list of polynomial coefficients. r>rr5r5r6 listcoeffsuszPolyElement.listcoeffscCs t|S)z(Unordered list of polynomial monomials. )r?rrr5r5r6 listmonomsyszPolyElement.listmonomscCs t|S)z$Unordered list of polynomial terms. rrr5r5r6 listterms}szPolyElement.listtermscCsB||jjkr||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)r7rclear)rrFrr5r5r6rQs zPolyElement.imul_numcCs0|jj}|j}|j}|D]}|||}q|S)z*Returns GCD of polynomial's coefficients. )r7r2rrr)rjr2contrrr5r5r6r3s   zPolyElement.contentcCs|}|||fS)z,Returns content and a primitive polynomial. )r3rX)rjrr5r5r6 primitiveszPolyElement.primitivecCs|s|S||jSdS)z5Divides all coefficients by the leading coefficient. N)rXr*rir5r5r6monicszPolyElement.moniccs,s |jjSfdd|D}||S)Ncsg|]\}}||fqSr5r5rrzr5r6r<sz*PolyElement.mul_ground..)r7rrr)rjrzrr5rr6rszPolyElement.mul_groundcs*|jjfdd|D}||S)Ncsg|]\}}||fqSr5r5r:Zf_monomZf_coeffrrr5r6r<sz)PolyElement.mul_monom..)r7rrIr)rjrrr5rr6 mul_monomszPolyElement.mul_monomcsZ|\|rs|jjS|jjkr.|S|jjfdd|D}||S)Ncs"g|]\}}||fqSr5r5rrrrr5r6r<sz(PolyElement.mul_term..)r7rr}rrrIr)rjrkrr5rr6mul_terms  zPolyElement.mul_termcsl|jj}std|r"|jkr&|S|jrL|jfdd|D}nfdd|D}||S)NrUcsg|]\}}||fqSr5r5rr`rzr5r6r<sz*PolyElement.quo_ground..cs$g|]\}}|s||fqSr5r5rrr5r6r<s)r7r2rVrrr`rr)rjrzr2rr5rr6rXszPolyElement.quo_groundcsl\}}|stdn"|s"|jjS||jjkr8||S|fdd|D}|dd|DS)NrUcsg|]}|qSr5r5r:trkrer5r6r<sz(PolyElement.quo_term..cSsg|]}|dk r|qSrTr5rr5r5r6r<s)rVr7rr}rXrfrr)rjrkrrrr5rr6quo_terms   zPolyElement.quo_termcsx|jjjrLg}|D]2\}}|}|dkr:|}|||fqnfdd|D}||}||S)Nr;csg|]\}}||fqSr5r5rrr5r6r<sz,PolyElement.trunc_ground..)r7r2is_ZZrrrr)rjrrrrrr5rr6 trunc_grounds   zPolyElement.trunc_groundcCsB|}|}|}|jj||}||}||}|||fSrT)r3r7r2rrX)rrnrjfcgcrr5r5r6extract_grounds  zPolyElement.extract_groundcs6|s|jjjS|jjj|fdd|DSdS)Ncsg|] }|qSr5r5)r:rZ ground_absr5r6r<sz%PolyElement._norm..)r7r2rabsr)rjZ norm_funcr5rr6_norms  zPolyElement._normcCs |tSrT)rrhrir5r5r6max_normszPolyElement.max_normcCs |tSrT)rrKrir5r5r6l1_normszPolyElement.l1_normcGs|j}|gt|}dg|j}|D]6}|D](}t|D]\}}t|||||<q.cSsg|]\}}||qSr5r5r:rrSr5r5r6r<9sz'PolyElement.deflate..) r7r?r|r9rr rlr[rrrMr)rjrmr7rQJrrrrErcHhIrNr5r5r6deflates*    zPolyElement.deflatecCs>|jj}|D](\}}ddt||D}||t|<q|S)NcSsg|]\}}||qSr5r5rr5r5r6r<Dsz'PolyElement.inflate..)r7rrrMrl)rjrrrrrr5r5r6inflate@s zPolyElement.inflatecCsf|}|jj}|js6|\}}|\}}|||}||||}|jsZ||S|SdSrT) r7r2rrrr`rrr)rrnrjr2rrrFrr5r5r6rIs    zPolyElement.lcmcCs||dSrs) cofactorsrjrnr5r5r6rYszPolyElement.gcdcCs|s|s|jj}|||fS|s8||\}}}|||fS|sV||\}}}|||fSt|dkr|||\}}}|||fSt|dkr||\}}}|||fS||\}\}}||\}}}||||||fSr)r7r _gcd_zerorm _gcd_monomr_gcdr)rjrnrrcffcfgrr5r5r6r\s$       zPolyElement.cofactorscCs4|jj|jj}}|jr"|||fS| || fSdSrT)r7rrr.)rjrnrrr5r5r6rrs zPolyElement._gcd_zeroc s|j}|jj}|jj|j}|jt|d\}}|||D]\}}||||qH|fg} |||fg} |fdd|D} | | | fS)Nrcs$g|]\}}||fqSr5r5)r:rorpZ_cgcdZ_mgcdZ ground_quorr5r6r<sz*PolyElement._gcd_monom..) r7r2rr`rrr?rr) rjrnr7Z ground_gcdrmfcfrorprrrr5rr6rys   "zPolyElement._gcd_monomcCs:|j}|jjr||S|jjr*||S|||SdSrT)r7r2Zis_QQ_gcd_QQr_gcd_ZZZ dmp_inner_gcd)rjrnr7r5r5r6rs   zPolyElement._gcdcCs t||SrTrrr5r5r6rszPolyElement._gcd_ZZc Cs|}|j}|j|jd}|\}}|\}}||}||}||\}}} ||}|j|} }|| |j | |}| | |j | |} ||| fS)Nr) r7rr2rrrrr*rrr`) rrnrjr7rrrprrrrFr5r5r6rs     zPolyElement._gcd_QQc Cs|}|j}|s||jfS|j}|jr*|js<||\}}}n|j|d}|\} }|\} }| |}| |}||\}}}|j| | \}} } | |}| |}| | }| | }| } | |jkr||}}n2| |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) r7rr2rrrrrrrrcanonical_unit) rrnrjr7r2rrrtrZcqcpur5r5r6cancels4              zPolyElement.cancelcCs|jj}||jSrT)r7r2rr*)rjr2r5r5r6rszPolyElement.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 )r7rrrrrr) rjrzr7rrErnrrer5r5r6diffs   zPolyElement.diffcGsTdt|kr|jjkr8nn|tt|jj|Std|jjt|fdS)Nrz1expected at least 1 and at most %s values, got %s)rmr7r|evaluater?rMr0r)rjr@r5r5r6r s zPolyElement.__call__c sH|}t|tr`|dkr`|d|dd\}}||}|sD|Sfdd|D}||S|j}||}|j|}|jdkr|jj}| D]\\}}||||7}q|S| |j} | D]t\} }| || d|| |dd}} |||}| | kr2|| | }|r*|| | <n| | =q|r|| | <q| SdS)Nrrcsg|]\}}||fqSr5)r)r:YrbXr5r6r< sz(PolyElement.evaluate..) rUr?rr7rr2rr|rrr) rrzrbrjr7rresultrrrrr5rr6r s8      &     zPolyElement.evaluatec Cs |}t|tr4|dkr4|D]\}}|||}q|S|j}||}|j|}|jdkr|jj}| D]\\}} || ||7}qj| |S|j} | D]x\} } | || d|d| |dd}} | ||} | | kr | | | } | r| | | <n| | =q| r| | | <q| SdS)Nrr`) rUr?subsr7rr2rr|rrr) rrzrbrjrr7rrrrrrr5r5r6r2 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)rrrgr5r6r< sz*PolyElement.symmetrize..cs,||fkr ||||f<||fSrTr5)rr) poly_powersrQr5r6get_poly_power s z.PolyElement.symmetrize..get_poly_powerrrr)rNNc3s"|]}||dkVqdSr5r5rrr5r6rY sz)PolyElement.symmetrize..css|]\}}||VqdSrTr5)r:rrEr5r5r6rY sNr`)rr7r|rrr?rrr[rhrMrrrlr0)rrjrrrweightsZ symmetric_heightZ_monomZ_coeffrrheightZ exponentsrqm2productrr5)rrrQr7r6 symmetrizeY s>;    zPolyElement.symmetrizec s|j}|j}tt|jt|j|dk r6||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 |dSrsr5)rZgens_mapr5r6rd rez%PolyElement.compose..rfz9expected a generator, value pair a sequence of such pairsr)r7rrLrMr0rr|rUr?rrIrrrrrrrl) rjrzrbr7rZ replacementsrrnrrZsubpolyrrr5rr6r 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||fqSr5r5rDdegrr5r6r< s z)PolyElement.coeff_wrt..cs,g|]$}|dd|ddqS)Nr`rr5)r:rErxr5r6r< s)r7rrrrMrNrL)rrzrrrrrPr5rr6 coeff_wrt 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 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 rrUrr7rr{rVrr0)rrnrzrjdfdgrjdrrlc_gxplc_rrSRrmrFr5r5r6prem 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. rrUrr)rrnrzrjrrrtrjrrrrrrSQrrmrFr5r5r6pdivv 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)rrnrzrjr5r5r6pquo 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 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 N)rr0r!)rrnrzrjrtrjr5r5r6pexquo 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)r7rr{rrrru)rrnrzrjrrErdrcrlcrFSrrrtr5r5r6 subresultants7 sF"                 zPolyElement.subresultantscCs|j||SrT)r7Zdmp_half_gcdexrr5r5r6 half_gcdex szPolyElement.half_gcdexcCs|j||SrT)r7Z dmp_gcdexrr5r5r6gcdex szPolyElement.gcdexcCs|j||SrT)r7Z dmp_resultantrr5r5r6 resultant szPolyElement.resultantcCs |j|SrT)r7Zdmp_discriminantrir5r5r6 discriminant szPolyElement.discriminantcCs |jjr|j|StddS)Nzpolynomial decomposition)r7rZ dup_decomposer"rir5r5r6 decompose s zPolyElement.decomposecCs"|jjr|j||StddS)Nzshift: use shift_list instead)r7rZ dup_shiftr"rjrbr5r5r6shift szPolyElement.shiftcCs|j||SrT)r7Z dmp_shiftrr5r5r6 shift_list szPolyElement.shift_listcCs |jjr|j|StddS)Nzsturm sequence)r7rZ dup_sturmr"rir5r5r6sturm s zPolyElement.sturmcCs |j|SrT)r7Z dmp_gff_listrir5r5r6gff_list szPolyElement.gff_listcCs |j|SrT)r7Zdmp_normrir5r5r6norm szPolyElement.normcCs |j|SrT)r7Z dmp_sqf_normrir5r5r6sqf_norm szPolyElement.sqf_normcCs |j|SrT)r7Z dmp_sqf_partrir5r5r6sqf_part szPolyElement.sqf_partFcCs|jj||dS)N)r[)r7Z dmp_sqf_list)rjr[r5r5r6sqf_list szPolyElement.sqf_listcCs |j|SrT)r7Zdmp_factor_listrir5r5r6 factor_list szPolyElement.factor_list)N)N)N)N)N)N)N)N)N)N)N)N)N)N)F)rqrrrrrrryrrrrrrrrrrr r r rrrrrrrrrrVrr)rr+r,rr-r.r/r0r1r2r4r:r<r>r?r@rArBrDrCrFrErJrGrPrOrNrMr[rWr_r^rbra __floordiv__ __rfloordiv__rfrr]r`rurhrir{r|r~rrrrrr*rrrlrrrPrrrr9rrrrrQr3rrrrrrXrrrYrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr5r5r5r6r_<sP     0                 6620$!L-,%   %      #   !  8 , 'm 5 [ ~%]            r_N)Qr __future__rtypingroperatorrrrrrr functoolsr typesr Zsympy.core.exprr Zsympy.core.intfuncr Zsympy.core.symbolrrrZZsympy.core.sympifyrrZsympy.ntheory.multinomialrZsympy.polys.compatibilityrZsympy.polys.constructorrZsympy.polys.densebasicrrrZ!sympy.polys.domains.domainelementrZ"sympy.polys.domains.polynomialringrZsympy.polys.heuristicgcdrZsympy.polys.monomialsrZsympy.polys.orderingsrZsympy.polys.polyerrorsrr r!r"Zsympy.polys.polyoptionsr#rnr$rpr%Zsympy.polys.polyutilsr&r'r(Zsympy.printing.defaultsr)Zsympy.utilitiesr*r+Zsympy.utilities.iterablesr,Zsympy.utilities.magicr-r7r8r=rRr]r^__annotations__r/rLr_r5r5r5r6sN                   4 z