o o hF@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_ringr5e/var/www/html/construction_image-detection-poc/venv/lib/python3.10/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 }zvring..)r/r-rr0r1r5r5r6vringas r>c sd}t|s |gd}}ttt|}t||}t||\}}|jdurGtdd|Dg}t||d\|_}t t ||fdd|D}t |j |j|j }tt|j|} |r`|| dfS|| fS) 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<zsring..)optcs"g|] }fdd|DqS)csi|] \}}||qSr5r5r:mc coeff_mapr5r6 z$sring...)itemsrBrIr5r6r<"r)r,r@maprr%r(r2sumrdictzipr/r0r3 from_dict) exprsroptionssinglerErepscoeffs coeffs_domr4polysr5rIr6srings     r[cCsnt|tr|r t|ddSdSt|tr|fSt|r3tdd|Dr(t|Stdd|Dr3|Std)NT)seqr5cs|]}t|tVqdSN) isinstancestrr:sr5r5r6 z!_parse_symbols..csr]r^)r_r rar5r5r6rcrdzbexpected a string, Symbol or expression or a non-empty sequence of strings, Symbols or expressions)r_r`_symbolsr r,allr rr5r5r6_parse_symbolss  rhzdict[Any, Any] _ring_cachec@s@eZdZdZefddZddZddZdd Zd d Z d d Z ddZ dGddZ ddZ eddZeddZdHddZddZddZdd ZeZdHd!d"ZdHd#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)Ir/z*Multivariate distributed polynomial ring. c stt|}t|}t|}t|j|||f}t|}|dur|j r5t |t |j @r5t dt |}||_t||_tdtfd|i|_||_ ||_||_|_d||_||_t |j|_|j|jfg|_|rt|}||_ |!|_"|#|_$|%|_&|'|_(|)|_*|+|_,ndd}||_ ||_"dd|_$||_&||_(||_*||_,t-urt.|_/nfdd|_/t0|j |jD]\} } t1| t2r| j3} t4|| st5|| | q|t|<|S) Nz7polynomial ring and it's ground domain share generators PolyElementr7rcSdSNr5r5)abr5r5r6z"PolyRing.__new__..cSrlrmr5)rnrorHr5r5r6rprqcs t|dS)Nkey)maxfr3r5r6rp )6tuplerhlen DomainOpt preprocessOrderOpt__name__riget is_Compositesetrr object__new__ _hash_tuplehash_hashtyperjdtypengensr2r3 zero_monom_gensr0 _gens_setone_onerr monomial_mulpow monomial_powmulpowmonomial_mulpowldiv monomial_ldivdiv monomial_divlcm monomial_lcmgcd monomial_gcdrrt leading_expvrRr_rr9hasattrsetattr) clsrr2r3rrobjcodegenmonunitsymbol generatorr9r5rwr6rsb                    zPolyRing.__new__cCsF|jj}g}t|jD]}||}|j}|||<||q t|S)z(Return a list of polynomial generators. )r2rrangermonomial_basiszeroappendry)selfrriexpvpolyr5r5r6rs  zPolyRing._genscCs|j|j|jfSr^)rr2r3rr5r5r6__getnewargs__zPolyRing.__getnewargs__cCs.|j}|d=|D] }|dr||=q |S)Nr monomial_)__dict__copy startswith)rstatersr5r5r6 __getstate__s  zPolyRing.__getstate__cCs|jSr^)rrr5r5r6__hash__ szPolyRing.__hash__cCs2t|to|j|j|j|jf|j|j|j|jfkSr^)r_r/rr2rr3rotherr5r5r6__eq__#s zPolyRing.__eq__cC ||k Sr^r5rr5r5r6__ne__( zPolyRing.__ne__NcCs ||p|j|p |j|p|jSr^) __class__rr2r3)rrr2r3r5r5r6clone+s zPolyRing.clonecCsdg|j}d||<t|S)zReturn the ith-basis element. r)rry)rrbasisr5r5r6r.s zPolyRing.monomial_basiscCs|Sr^)rrr5r5r6r4sz PolyRing.zerocCs ||jSr^)rrrr5r5r6r8 z PolyRing.onecCs|j||Sr^)r2convertrelement orig_domainr5r5r6 domain_new<zPolyRing.domain_newcCs||j|Sr^)term_newr)rcoeffr5r5r6 ground_new?rzPolyRing.ground_newcCs ||}|j}|r|||<|Sr^)rr)rmonomrrr5r5r6rBs zPolyRing.term_newcCst|tr"||jkr |St|jtr|jj|jkr||Stdt|tr+tdt|tr5| |St|t rOz| |WSt yN| |YSwt|trY||S||S)N conversionparsing)r_rjr7r2rrNotImplementedErrorr`rQrSr@ from_terms ValueError from_listr from_exprrrr5r5r6ring_newIs&            zPolyRing.ring_newcCs8|j}|j}|D]\}}|||}|r|||<q |Sr^)rrrM)rrrrrrrr5r5r6rSas zPolyRing.from_dictcCs|t||Sr^)rSrQrr5r5r6rlrzPolyRing.from_termscCs|t||jd|jSNr)rSrrr2rr5r5r6roszPolyRing.from_listcs$jfddt|S)Ncs|}|dur |S|jrtttt|jS|jr'tttt|jS| \}}|j r<|dkr<|t |S  |Sr)ris_Addr rr@rOargsis_Mulr as_base_exp is_Integerintrr)exprrbaseexp_rebuildr2mappingrr5r6rus  z(PolyRing._rebuild_expr.._rebuild)r2r)rrrr5rr6 _rebuild_exprrs zPolyRing._rebuild_exprcCsPttt|j|j}z|||}Wnty"td||fw||S)Nz@expected an expression convertible to a polynomial in %s, got %s) rQr@rRrr0rrrr)rrrrr5r5r6rs  zPolyRing.from_exprcCs|dur|jr d}|Sd}|St|tr9|}d|kr"||jkr" |S|j |kr3|dkr3| d}|Std|t||jrVz |j|}W|StyUtd|wt|trrz |j|}W|Styqtd|wtd|)z+Compute index of ``gen`` in ``self.gens``. Nrrzinvalid generator index: %szinvalid generator: %szEexpected a polynomial generator, an integer, a string or None, got %s) rr_rrrr0indexr`r)rgenrr5r5r6rs<       zPolyRing.indexcs>tt|j|fddt|jD}|s|jS|j|dS)z,Remove specified generators from this ring. cg|] \}}|vr|qSr5r5r:rrbindicesr5r6r<z!PolyRing.drop..rg)rrOr enumeraterr2rrr0rr5rr6drops  z PolyRing.dropcCs |j|}|s |jS|j|dS)Nrg)rr2r)rrsrr5r5r6 __getitem__s  zPolyRing.__getitem__cCs2|jjs t|jdr|j|jjdStd|j)Nr2r2z%s is not a composite domain)r2rrrrrr5r5r6 to_groundszPolyRing.to_groundcCt|Sr^rrr5r5r6 to_domainzPolyRing.to_domaincCsddlm}||j|j|jS)Nr) FracField)sympy.polys.fieldsrrr2r3)rrr5r5r6to_fields zPolyRing.to_fieldcCst|jdkSrrzr0rr5r5r6 is_univariatezPolyRing.is_univariatecCst|jdkSrrrr5r5r6is_multivariaterzPolyRing.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 rrobjsprr5r5r6r   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 rrr5r5r6rrz PolyRing.mulcs\tt|j|fddt|jD}fddt|jD}|s$|S|j||j|dS)zd Remove specified generators from the ring and inject them into its domain. crr5r5rrr5r6r<rz+PolyRing.drop_to_ground..crr5r5)r:rrrr5r6r<rrr2)rrOrrrr0rrrr5rr6drop_to_grounds zPolyRing.drop_to_groundcCs2||krt|jt|j}|jt|dS|S)z+Add the generators of ``other`` to ``self``rgrrunionrr@)rrsymsr5r5r6composeszPolyRing.composecCs$t|jt|}|jt|dS)z9Add the elements of ``symbols`` as generators to ``self``rgr)rrrr5r5r6add_gens&szPolyRing.add_genscs|dks ||jkrtd||jf|s|jS|j}tt|jt|D]tfddt|jD}|| ||j j7}q$|S)zo Return the elementary symmetric polynomial of degree *n* over this ring's generators. rz7Cannot generate symmetric polynomial of order %s for %sc3s|] }t|vVqdSr^)rr:rrbr5r6rc7z*PolyRing.symmetric_poly..) rrr0rrr+rrryrr2)rnrrr5r r6symmetric_poly+szPolyRing.symmetric_poly)NNNr^))r~ __module__ __qualname____doc__rrrrrrrrrrpropertyrrrrrr__call__rSrrrrrrrrrrrrrrrrrr r5r5r5r6r/sR 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 dZddZddZddZddZddZddZddZd#ddZd d!ZdS($rjz5Element of multivariate distributed polynomial ring. cCs ||Sr^)r)rinitr5r5r6new?rzPolyElement.newcCs |jSr^)r7rrr5r5r6parentBrzPolyElement.parentcCs|jt|fSr^)r7r@ itertermsrr5r5r6rEzPolyElement.__getnewargs__NcCs.|j}|durt|jt|f|_}|Sr^)rrr7 frozensetrM)rrr5r5r6rJszPolyElement.__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 )rrr5r5r6rUs zPolyElement.copycCsV|j|kr|S|jj|jkr#ttt||jj|j}|||jjS|||jjSr^)r7rr@rRr'rr2rS)rnew_ringtermsr5r5r6set_ringqs zPolyElement.set_ringcGsJ|s|jj}nt||jjkrtd|jjt|ft|g|RS)Nz+Wrong number of symbols, expected %s got %s)r7rrzrrr& as_expr_dict)rrr5r5r6as_exprzs zPolyElement.as_exprcs |jjjfdd|DS)Ncsi|] \}}||qSr5r5r:rrto_sympyr5r6rKrLz,PolyElement.as_expr_dict..)r7r2rrrr5rr6rs zPolyElement.as_expr_dictcsx|jj}|jr |js|j|fS|}|j|j}|j}|D] }|||q | fdd| D}|fS)Ncg|] \}}||fqSr5r5)r:kvcommonr5r6r<rz,PolyElement.clear_denoms..) r7r2is_Fieldhas_assoc_Ringrget_ringrdenomrArrM)rr2 ground_ringrr(rrr5r#r6 clear_denomss   zPolyElement.clear_denomscCs$t|D] \}}|s||=qdS)z+Eliminate monomials with zero coefficient. Nr@rM)rr!r"r5r5r6 strip_zeros zPolyElement.strip_zerocCsN|s| St|tr|j|jkrt||St|dkrdS||jj|kS)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 rF)r_rjr7rQrrzrrp1p2r5r5r6rs  zPolyElement.__eq__cCrr^r5r-r5r5r6rrzPolyElement.__ne__cCs|j}t||jr1t|t|krdS|jj}|D]}||||||s.dSqdSt|dkr9dSz|j|}Wn t yKYdSw|j| ||S)z+Approximate equality test for polynomials. FTr) r7r_rrkeysr2almosteqrzrrconst)r.r/ tolerancer7r1r!r5r5r6r1s$    zPolyElement.almosteqcCst||fSr^)rzrrr5r5r6sort_keyrzPolyElement.sort_keycCs$t||jjr|||StSr^)r_r7rr4NotImplemented)r.r/opr5r5r6_cmpszPolyElement._cmpcC ||tSr^)r7rr-r5r5r6__lt__ zPolyElement.__lt__cCr8r^)r7rr-r5r5r6__le__r:zPolyElement.__le__cCr8r^)r7rr-r5r5r6__gt__r:zPolyElement.__gt__cCr8r^)r7r r-r5r5r6__ge__r:zPolyElement.__ge__cCsD|j}||}|jdkr||jfSt|j}||=||j|dfS)Nrrg)r7rrr2r@rrrrr7rrr5r5r6_drops    zPolyElement._dropcCs||\}}|jjdkr|jr|dStd||j}|D]\}}||dkr:t|}||=||t |<q"td||S)NrzCannot drop %sr) r?r7r is_groundrrrrMr@ry)rrrr7rr!r"Kr5r5r6rs     zPolyElement.dropcCs6|j}||}t|j}||=||j|||dfS)Nr)r7rr@rrr>r5r5r6_drop_to_grounds   zPolyElement._drop_to_groundcCs|jjdkr td||\}}|j}|jjd}|D]1\}}|d|||dd}||vr@||||||<q||||||7<q|S)Nrz$Cannot drop only generator to groundr) r7rrrBrr2r0r mul_ground)rrrr7rrrmonr5r5r6rs   zPolyElement.drop_to_groundcCst||jjd|jjSr)rr7rr2rr5r5r6to_dense zPolyElement.to_densecCrr^)rQrr5r5r6to_dict#rzPolyElement.to_dictcCs|s ||jjjS|d}|d}|j}|j}|j} |j} g} |D]\} } |j| }|r2dnd}| || | krP|| }|rO| drO|dd}n|rU| } | |jjj kre|j | |dd}nd }g}t | D]=}| |}|svqm|j |||dd}|dkr|t|ks|d kr|j ||d d}n|}| |||fqm| d |qm|r|g|}| ||q$| d d vr| d }|dkr| d dd | S)NMulAtom -  + -rT)strictrFz%s)rKrJ)_printr7r2rrrrr is_negativerrr parenthesizerrjoinpopinsert)rprinter precedence exp_pattern mul_symbolprec_mul prec_atomr7rrzmsexpvsrrnegativesignscoeffsexpvrrrsexpheadr5r5r6r`&sV           zPolyElement.strcCs ||jjvSr^)r7rrr5r5r6 is_generatorVrzPolyElement.is_generatorcCs| pt|dko|jj|vSr)rzr7rrr5r5r6r@ZszPolyElement.is_groundcCs| p t|dko |jdkSr)rzLCrr5r5r6 is_monomial^szPolyElement.is_monomialcCs t|dkSr)rzrr5r5r6is_termbrzPolyElement.is_termcC|jj|jSr^)r7r2rPrdrr5r5r6rPfzPolyElement.is_negativecCrgr^)r7r2 is_positiverdrr5r5r6rijrhzPolyElement.is_positivecCrgr^)r7r2is_nonnegativerdrr5r5r6rjnrhzPolyElement.is_nonnegativecCrgr^)r7r2is_nonpositiverdrr5r5r6rkrrhzPolyElement.is_nonpositivecCs| Sr^r5rur5r5r6is_zerovszPolyElement.is_zerocCs ||jjkSr^)r7rrur5r5r6is_onezrzPolyElement.is_onecCrgr^)r7r2rmrdrur5r5r6is_monic~rhzPolyElement.is_moniccCs|jj|Sr^)r7r2rmcontentrur5r5r6 is_primitiveszPolyElement.is_primitivecCtdd|DS)Ncs|] }t|dkVqdSrNrPr:rr5r5r6rcr z(PolyElement.is_linear..rf itermonomsrur5r5r6 is_linearzPolyElement.is_linearcCrq)Ncsrr)Nrtrur5r5r6rcr z+PolyElement.is_quadratic..rvrur5r5r6 is_quadraticryzPolyElement.is_quadraticcC|jjsdS|j|SNT)r7r dmp_sqf_prur5r5r6 is_squarefree zPolyElement.is_squarefreecCr|r})r7rdmp_irreducible_prur5r5r6is_irreduciblerzPolyElement.is_irreduciblecC|jjr |j|Std)Nzcyclotomic polynomial)r7rdup_cyclotomic_pr"rur5r5r6 is_cyclotomics zPolyElement.is_cyclotomiccCs|dd|DS)NcSsg|] \}}|| fqSr5r5rr5r5r6r<rLz'PolyElement.__neg__..)rrrr5r5r6__neg__rFzPolyElement.__neg__cCs|Sr^r5rr5r5r6__pos__zPolyElement.__pos__c Cs<|s|S|j}t||jr6|}|j}|jj}|D]\}}||||}|r0|||<q||=q|St|tr^t|jt rI|jj|jkrInt|jjt r\|jjj|kr\| |St Sz| |}Wn t ypt YSw|}|sy|S|j} | |vr||| <|S|||  kr|| =|S|| |7<|S)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 )rr7r_rrr2rrMrjr__radd__r5rrrr0) r.r/r7rrrr!r"cp2r[r5r5r6__add__sH      zPolyElement.__add__cCs|}|s|S|j}z||}Wn tytYSw|j}||vr-|||<|S||| kr9||=|S|||7<|Sr^)rr7rrr5rr0)r.r rr7r[r5r5r6rs$  zPolyElement.__radd__c Cs4|s|S|j}t||jr6|}|j}|jj}|D]\}}||||}|r0|||<q||=q|St|tr^t|jt rI|jj|jkrInt|jjt r\|jjj|kr\| |St Sz| |}Wn t ypt YSw|}|j}||vr| ||<|S|||kr||=|S|||8<|S)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 )rr7r_rrr2rrMrjr__rsub__r5rrrr0) r.r/r7rrrr!r"r[r5r5r6__sub__sD        zPolyElement.__sub__cCsV|j}z||}Wn tytYSw|j}|D] }|| ||<q||7}|S)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 )r7rrr5r)r.r r7rrr5r5r6r's zPolyElement.__rsub__cCs0|j}|j}|r |s |St||jrH|j}|jj}|j}t|}|D]\}} |D]\} } ||| } || || | || <q,q&| |St|t rpt|jt r[|jj|jkr[nt|jjt rn|jjj|krn| |St Sz||}Wn tyt YSw|D]\}} | |} | r| ||<q|S)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 )r7rr_rrr2rr@rMr,rjr__rmul__r5rr)r.r/r7rrrrp2itexp1v1exp2v2rr"r5r5r6__mul__BsB       zPolyElement.__mul__cCsb|jj}|s|Sz|j|}Wn tytYSw|D]\}}||}|r.|||<q |S)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 )r7rrrr5rM)r.r/rrrr"r5r5r6rts zPolyElement.__rmul__cCs|j}|s|r |jStdt|dkr=t|d\}}|j}||jjkr1|||||<|S||||||<|St |}|dkrItd|dkrQ| S|dkrY| S|dkrc|| St|dkrn| |S| |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 z0**0rrzNegative exponentrz)r7rrrzr@rMrr2rrrsquare_pow_multinomial _pow_generic)rr r7rrrr5r5r6__pow__s2      zPolyElement.__pow__cCsB|jj}|} |d@r||}|d8}|s |S|}|d}q)NTrrz)r7rr)rr rrHr5r5r6rszPolyElement._pow_genericcCstt||}|jj}|jj}|}|jjj}|jj}|D]>\}} |} | } t||D]\} \} }| rA|| | | } | || 9} q-t | } | }| | ||}|rW||| <q | |vr^|| =q |Sr^) rrzrMr7rrr2rrRryr)rr  multinomialsrrrrr multinomialmultinomial_coeff product_monom product_coeffrrrr5r5r6rs.     zPolyElement._pow_multinomialcCs|j}|j}|j}t|}|jj}|j}tt|D]'}||}||} t|D]} || } ||| } || || || || <q*q| d}|j}| D]\} }|| | } || ||d|| <qP| |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 rz) r7rrr@r0r2rrrzimul_numrMr,)rr7rrr0rrrk1pkjk2rr!r"r5r5r6rs*     zPolyElement.squarecCs|j}|s tdt||jr||St|tr.term_divcsJ|\}}|\}}|kr|}n||}|dus#||s#|||fSdSr^r5rrr5r6rxs )r7rr2rrr%)rr2rr5rr6 _term_dives zPolyElement._term_divcs|jd}t|trd}|g}t|std|s&|r!jjfSgjfS|D] }|jkr3tdq(t|}fddt|D}| }j}| }dd|D} |rd} d} | |kr| dkr| } || || f| | || | | f} | d ur| \}}||  ||f|| <| || || f}d } n| d 7} | |kr| dksc| s| } | | || f}|| =|sW| jkr||7}|r|s͈j|fS|d|fS||fS) 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 FTrz"self and f must have the same ringcsg|]}jqSr5)rrr7r5r6r<r=z#PolyElement.div..cSsg|]}|qSr5)r)r:fxr5r5r6r<rNr)r7r_rjrfrrrrzrrrr _iadd_monom_iadd_poly_monomr)rfv ret_singlervrbqvrrrexpvsr divoccurredrtermexpv1rHr5rr6rs\    &    zPolyElement.divcCs>|}t|tr |g}t|std|j}|j}|j}|j}|j}|}|j } | }|j } |r|D]A} || | j } | durt| \} }| D]\}}||| }| ||||}|s_||=qG|||<qG| }|durr|||f} n'q3| \}}||vr|||7<n|||<||=| }|dur|||f} |s1|Sr)r_rjrfrr7r2rrrLTrrrr)rGrvr7r2rrrrltfrgtqrGrHmgcgm1c1ltmltcr5r5r6rsP      zPolyElement.remcC||dSNr)r)rvrr5r5r6rrzPolyElement.quocCs ||\}}|s |St||r^)rr!)rvrqrr5r5r6exquos zPolyElement.exquocCsb||jjvr |}n|}|\}}||}|dur |||<|S||7}|r,|||<|S||=|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)r7rrr)rmccpselfrrrHr5r5r6r s   zPolyElement._iadd_monomc Cs~|}||jjvr |}|\}}|j}|jjj}|jj}|D]\} } || |} || || |} | r9| || <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 )r7rrrr2rrrM) rr/rr.rGrHrrrr!r"karr5r5r6r6s    zPolyElement._iadd_poly_monomc:|j||s tSdkrdStfdd|DS)z The leading degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3|]}|VqdSr^r5rurr5r6rciz%PolyElement.degree..)r7rrrtrwrvxr5rr6degree[ zPolyElement.degreecC,|s tf|jjSttttt|S)z A tuple containing leading degrees in all variables. Note that the degree of 0 is negative infinity (``float('-inf')``) ) rr7rryrOrtr@rRrwrur5r5r6degreeskzPolyElement.degreescr)z The tail degree in ``x`` or the main variable. Note that the degree of 0 is negative infinity (``float('-inf')``) rc3rr^r5rurr5r6rcrz*PolyElement.tail_degree..)r7rrminrwrr5rr6 tail_degreewrzPolyElement.tail_degreecCr)z A tuple containing tail degrees in all variables. Note that the degree of 0 is negative infinity (``float('-inf')``) ) rr7rryrOrr@rRrwrur5r5r6 tail_degreesrzPolyElement.tail_degreescCs|r|j|SdS)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|||jjjSr^)rr7r2rrrr5r5r6 _get_coeffrzPolyElement._get_coeffcCsl|dkr ||jjSt||jjr0t|}t|dkr0|d\}}||jjj kr0||St d|)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) rr7rr_rr@rrzr2rr)rrrrrr5r5r6rs     zPolyElement.coeffcCs||jjS)z"Returns the constant coefficient. )rr7rrr5r5r6r2rzPolyElement.constcCs||Sr^)rrrr5r5r6rdrzPolyElement.LCcCs|}|dur |jjS|Sr^)rr7rrr5r5r6LMszPolyElement.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_monomcCs0|}|dur|jj|jjjfS|||fSr^)rr7rr2rrrr5r5r6rszPolyElement.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)r7rrrr5r5r6 leading_terms  zPolyElement.leading_termcsLdur |jjntturt|ddddSt|fddddS)NcSs|dSrr5rr5r5r6rpsz%PolyElement._sorted..T)rsreversecs |dSrr5rrwr5r6rprx)r7r3r}r|rsorted)rr\r3r5rwr6_sorteds   zPolyElement._sortedcCdd||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<3rz&PolyElement.coeffs..rrr3r5r5r6rXzPolyElement.coeffscCr)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<Mrz&PolyElement.monoms..rrr5r5r6monoms5rzPolyElement.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@rMrr5r5r6rOrzPolyElement.termscC t|S)z,Iterator over coefficients of a polynomial. )iterrArr5r5r6 itercoeffsirzPolyElement.itercoeffscCr)z)Iterator over monomials of a polynomial. )rr0rr5r5r6rwmrzPolyElement.itermonomscCr)z%Iterator over terms of a polynomial. )rrMrr5r5r6rqrzPolyElement.itertermscCr)z+Unordered list of polynomial coefficients. r?rr5r5r6 listcoeffsurzPolyElement.listcoeffscCr)z(Unordered list of polynomial monomials. )r@r0rr5r5r6 listmonomsyrzPolyElement.listmonomscCr)z$Unordered list of polynomial terms. r+rr5r5r6 listterms}rzPolyElement.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)r7rclear)rrHrr5r5r6rs zPolyElement.imul_numcCs0|jj}|j}|j}|D]}|||}q|S)z*Returns GCD of polynomial's coefficients. )r7r2rrr)rvr2contrrr5r5r6ros   zPolyElement.contentcCs|}|||fS)z,Returns content and a primitive polynomial. )ror)rvrr5r5r6 primitiveszPolyElement.primitivecCs|s|S||jS)z5Divides all coefficients by the leading coefficient. )rrdrur5r5r6monics zPolyElement.moniccs,s|jjSfdd|D}||S)Ncr r5r5rrr5r6r<rz*PolyElement.mul_ground..)r7rrr)rvrrr5rr6rCs zPolyElement.mul_groundcs*|jjfdd|D}||S)Ncsg|] \}}||fqSr5r5r:f_monomf_coeffrrr5r6r<z)PolyElement.mul_monom..)r7rrMr)rvrrr5r r6 mul_monoms zPolyElement.mul_monomcsZ|\|rs |jjS|jjkr|S|jjfdd|D}||S)Ncs"g|] \}}||fqSr5r5rrrrr5r6r<rNz(PolyElement.mul_term..)r7rrrCrrMr)rvrrr5rr6mul_terms   zPolyElement.mul_termcsl|jj}s td|r|jkr|S|jr&|jfdd|D}n fdd|D}||S)Nrcsg|] \}}||fqSr5r5rrrr5r6r<r z*PolyElement.quo_ground..cs$g|]\}}|s||fqSr5r5rrr5r6r<$)r7r2rrr%rrr)rvrr2rr5rr6rs zPolyElement.quo_groundcsj\}}|s td|s|jjS||jjkr||S|fdd|D}|dd|DS)Nrcsg|]}|qSr5r5r:trrr5r6r<sz(PolyElement.quo_term..cSsg|]}|dur|qSr^r5rr5r5r6r<rD)rr7rrrrrr)rvrrrrr5rr6quo_terms  zPolyElement.quo_termcsx|jjjr&g}|D]\}}|}|dkr|}|||fq n fdd|D}||}||S)Nrzcsg|] \}}||fqSr5r5rrr5r6r<rz,PolyElement.trunc_ground..)r7r2is_ZZrrrr,)rvrrrrrr5rr6 trunc_grounds   zPolyElement.trunc_groundcCsB|}|}|}|jj||}||}||}|||fSr^)ror7r2rr)rrrvfcgcrr5r5r6extract_grounds   zPolyElement.extract_groundcs2|s|jjjS|jjj|fdd|DS)Ncsg|]}|qSr5r5)r:r ground_absr5r6r<rz%PolyElement._norm..)r7r2rabsr)rv norm_funcr5rr6_norms  zPolyElement._normcC |tSr^)r rtrur5r5r6max_normrzPolyElement.max_normcCr!r^)r rPrur5r5r6l1_normrzPolyElement.l1_normcGs|j}|gt|}dg|j}|D]}|D]}t|D] \}}t|||||<qqqt|D] \}} | s.cSsg|]\}}||qSr5r5r:rrr5r5r6r<9rDz'PolyElement.deflate..) r7r@rrwrr ryrfrrrRr)rvrr7rZJrrrrGroHhIrNr5r5r6deflates0   zPolyElement.deflatecCs>|jj}|D]\}}ddt||D}||t|<q|S)NcSsg|]\}}||qSr5r5r$r5r5r6r<DrDz'PolyElement.inflate..)r7rrrRry)rvr%rr(rr)r5r5r6inflate@s zPolyElement.inflatecCsb|}|jj}|js|\}}|\}}|||}||||}|js-||S|Sr^) r7r2r%rrrrrCr)rrrvr2rrrHr'r5r5r6rIs    zPolyElement.lcmcCrr) cofactorsrvrr5r5r6rYrzPolyElement.gcdcCs|s |s |jj}|||fS|s||\}}}|||fS|s+||\}}}|||fSt|dkr>||\}}}|||fSt|dkrQ||\}}}|||fS||\}\}}||\}}}||||||fSr)r7r _gcd_zerorz _gcd_monomr*_gcdr+)rvrrr'cffcfgr%r5r5r6r,\s$       zPolyElement.cofactorscCs0|jj|jj}}|jr|||fS| || fSr^)r7rrrj)rvrrrr5r5r6r.rs zPolyElement._gcd_zeroc s|j}|jj}|jj|j}|jt|d\}}|||D]\}}||||q$|fg} |||fg} |fdd|D} | | | fS)Nrcs$g|]\}}||fqSr5r5)r:rr_cgcd_mgcd ground_quorr5r6r<rz*PolyElement._gcd_monom..) r7r2rrrrr@rr) rvrr7 ground_gcdrmfcfrrr'r1r2r5r3r6r/ys   " zPolyElement._gcd_monomcCs6|j}|jjr ||S|jjr||S|||Sr^)r7r2is_QQ_gcd_QQr_gcd_ZZ dmp_inner_gcd)rvrr7r5r5r6r0s    zPolyElement._gcdcCs t||Sr^rr-r5r5r6r<rzPolyElement._gcd_ZZc Cs|}|j}|j|jd}|\}}|\}}||}||}||\}}} ||}|j|} }|| |j | |}| | |j | |} ||| fS)Nr) r7rr2r'r*rr<rdrrCr) rrrvr7rr9rr'r1r2rHr5r5r6r;s      zPolyElement._gcd_QQc Cs&|}|j}|s ||jfS|j}|jr|js||\}}}nD|j|d}|\} }|\} }| |}| |}||\}}}|j| | \}} } | |}| |}| | }| | }| } | |jkrt||}}||fS| |j kr| | }}||fS| | }| | }||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) r7rr2r%r&r,rr'r*rrCcanonical_unit) rrrvr7r2rrrrcqcpur5r5r6cancels8              zPolyElement.cancelcCs|jj}||jSr^)r7r2r>rd)rvr2r5r5r6r>s zPolyElement.canonical_unitc Cs`|j}||}||}|j}|D]\}}||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) rvrr7rrGrrrer5r5r6diffs   zPolyElement.diffcGsPdt|kr|jjkrnn |tt|jj|Std|jjt|f)Nrz1expected at least 1 and at most %s values, got %s)rzr7revaluater@rRr0r)rvrAr5r5r6r s zPolyElement.__call__c s@|}t|tr0|dur0|d|dd\}}||}|s"|Sfdd|D}||S|j}||}|j|}|jdkr[|jj}| D] \\}}||||7}qK|S| |j} | D]8\} }| || d|| |dd}} |||}| | vr|| | }|r|| | <qe| | =qe|r|| | <qe| S)Nrrcsg|] \}}||fqSr5)r)r:YrnXr5r6r< r z(PolyElement.evaluate..) r_r@rEr7rr2rrrrr) rrrnrvr7rresultr rrrr5rGr6rE s:      &   zPolyElement.evaluatec Cs|}t|tr|dur|D] \}}|||}q |S|j}||}|j|}|jdkrH|jj}| D] \\}} || ||7}q5| |S|j} | D]:\} } | || d|d| |dd}} | ||} | | vr| | | } | r| | | <qO| | =qO| r| | | <qO| S)Nrrk) r_r@subsr7rr2rrrrr) rrrnrvrHr7rrIr rrrr5r5r6rJ2 s4     *   zPolyElement.subscs|}|jj}|s|jgfSfddt|Difdd}tt|d}tt|dd}j}|rd\}}} t|D])\} \} tfd d |Drot d d t |D} | |kro| | }}} qF|dkrz|| } nn;g} t dd d D] \}}| ||q| t | | 7}| }t| D] \} }||| |9}q||8}|s;tt 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)r rrr5r6r< rLz*PolyElement.symmetrize..cs,||fvr||||f<||fSr^r5)rr ) poly_powersrZr5r6get_poly_power s  z.PolyElement.symmetrize..get_poly_powerrrr)rNNc3s$|] }||dkVqdSrsr5rrr5r6rc s"z)PolyElement.symmetrize..css|] \}}||VqdSr^r5)r:r rGr5r5r6rc r Nrk)rr7rrrr@rrrfrtrRrrryr0)rrvr rLrweights symmetric_height_monom_coeffrrheight exponentsrm2productrr5)rrKrZr7r6 symmetrizeY sB;    zPolyElement.symmetrizec s|j}|j}tt|jt|j|dur||fg}n t|tr%t|}nt|tr7t | fddd}nt dt |D]\}\}}|| |f||<q?|D]0\}} t|}|j} |D]\} }|| d} || <| rw| || 9} qb| t|| f} || 7}qU|S)Ncs |dSrr5)r!gens_mapr5r6rp rxz%PolyElement.compose..rrz9expected a generator, value pair a sequence of such pairsr)r7rrQrRr0rrr_r@rrMrrrrrrry) rvrrnr7r replacementsr!rrrsubpolyrr r5rWr6r s.       zPolyElement.composecsh|}|j|fdd|D}|s|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||fqSr5r5rFdegrr5r6r< rz)PolyElement.coeff_wrt..cs,g|]}|dd|ddqS)Nrkrr5)r:rGrr5r6r< s,)r7rrrrRrSrQ)rrr\rrrrXr5r[r6 coeff_wrt s*  zPolyElement.coeff_wrtcCs|}|j|}||}||}|dkrtd||}}||kr%|S||d}|||} |jj|} |||} |||d} }|| } || | | }| |}||}||kranq8| |}||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 rrrr7rrrr]r0)rrrrvdfdgrdrr)lc_gxplc_rrRrrHr5r5r6prem s06         zPolyElement.premcCs|}|j|}||}||}|dkrtd|||}}}||kr*||fS||d} |||} |jj|} |||} ||| d} } || }|| | | }|| }|| | | }||}||}||krrnq=| | }||}||}||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. rrrr^)rrrrvr_r`rrrar)rbrcrdrQrerrHr5r5r6pdivv s8P        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)rh)rrrrvr5r5r6pquo szPolyElement.pquocCs(|}|||\}}|jr|St||)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 )rhrlr!)rrrrvrrr5r5r6pexquo s  zPolyElement.pexquocCsV|}|j|}||}||}||kr ||}}||}}|dkr(ddgS|dkr0|dgS||g}||}d|d}|||} | |} |||} | |} d| g} | } | r| |} || || | || f\}}}}| | |}|||} | |} ||| } |dkr| |}| |d}||} n| } | | | s[|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)r7rrrfr]rr)rrrrvr rGredror'lcrHSr!rrr5r5r6 subresultants7 sH"                 zPolyElement.subresultantscC|j||Sr^)r7dmp_half_gcdexr-r5r5r6 half_gcdex rzPolyElement.half_gcdexcCror^)r7 dmp_gcdexr-r5r5r6gcdex rzPolyElement.gcdexcCror^)r7 dmp_resultantr-r5r5r6 resultant rzPolyElement.resultantcC |j|Sr^)r7dmp_discriminantrur5r5r6 discriminant r:zPolyElement.discriminantcCr)Nzpolynomial decomposition)r7r dup_decomposer"rur5r5r6 decompose  zPolyElement.decomposecCs|jjr |j||Std)Nzshift: use shift_list instead)r7r dup_shiftr"rvrnr5r5r6shift szPolyElement.shiftcCror^)r7 dmp_shiftr}r5r5r6 shift_list rzPolyElement.shift_listcCr)Nzsturm sequence)r7r dup_sturmr"rur5r5r6sturm r{zPolyElement.sturmcCrvr^)r7 dmp_gff_listrur5r5r6gff_list r:zPolyElement.gff_listcCrvr^)r7dmp_normrur5r5r6norm r:zPolyElement.normcCrvr^)r7 dmp_sqf_normrur5r5r6sqf_norm r:zPolyElement.sqf_normcCrvr^)r7 dmp_sqf_partrur5r5r6sqf_part r:zPolyElement.sqf_partFcCs|jj||dS)N)rf)r7 dmp_sqf_list)rvrfr5r5r6sqf_list rzPolyElement.sqf_listcCrvr^)r7dmp_factor_listrur5r5r6 factor_list r:zPolyElement.factor_listr^)F)r~r rrrrrrrrrrrr*r,rrr1r4r7r9r;r<r=r?rrBrrErGr`rrcr@rerfrPrirjrkrlrmrnrprxr{rrrrrrrrrrrrrrrrrrrrr __floordiv__ __rfloordiv__rrrrrrrrrrrrrrr2rdrrrrrrXrrrrwrrrrrrorrrCr rrrrrrr r"r#r*r+rrr,r.r/r0r<r;rBr>rDrrErJrVrr]rfrhrirjrnrqrsrurxrzr~rrrrrrrrr5r5r5r6rj<sR     0                 6620$!L-, %  %     #   !  8  ,' m 5 [~% ]           rjN)Qr __future__rtypingroperatorrrrrrr functoolsr typesr sympy.core.exprr sympy.core.intfuncr sympy.core.symbolrrresympy.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.polyerrorsrr 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-r7r8r>r[rhri__annotations__r/rQrjr5r5r5r6sP                   4 z