wgh#dZddlmZmZddlmZddlmZddlm Z m Z m Z m Z ddl mZddlmZddlmZmZmZdd lmZmZmZmZmZdd lmZdd lmZmZdd l m!Z!dd l"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*ddl+m,Z,m-Z-ddl.m/Z/m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z8ddl9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBddlCmDZEddlFmGZGddlHmIZIddlJmKZKmLZLmMZMddlNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`ddlambZbdd lcmdZddd!lemfZfmgZgmhZhdd"limjZjdd#lkmlZlmmZmdd$l6Zndd$loZodd%lpmqZqd&ZregGd'd(eZsegGd)d*esZtegd+Zud,Zvegd-Zwd.Zxd/Zyegdvd0Zzegd1Z{egd2Z|egd3Z}egd4Z~egd5Zegd6Zegd7Zegd8Zegd9Zegd:Zegd;Zegd<Zegd=Zegd>Zegd?Zegd@ZegdAZegdBdCdDZegdEZegdFZegdGZegdwdHZegdIZegdwdJZegdKZegdLZegdMZegdNZegdOZegdPZegdQZegdRZegdSZegdTZegdUZegdVZdWZdXZdYZdZZd[Zd\Zd]Zd^Zegd_Zegd`ZegdaZegdBdbdcZegdxddZegdydeZegdzdfZegd{dhZegd{diZegd|djZegdkZegdlZegdgdmdnZegdoZegdpZDegdqZegGdrdseZegdtZduZy$)}z8User-friendly public interface to polynomial functions. )wrapsreducemul)Optional)SExprAddTuple)Basic) _sympifyit)Factors factor_nc factor_terms) pure_complexevalffastlog_evalf_with_bounded_errorquad_to_mpmath) Derivative)Mul _keep_coeff)ilcm)IInteger equal_valued) RelationalEquality)ordered)DummySymbol)sympify_sympify)preorder_traversal bottom_up) BooleanAtom) polyoptions)construct_domain)FFQQZZ) DomainElement) matrix_fglm)groebner)Monomial) monomial_key)DMPDMFANP) OperationNotSupported DomainErrorCoercionFailedUnificationFailedGeneratorsNeededPolynomialErrorMultivariatePolynomialErrorExactQuotientFailedPolificationFailedComputationFailedGeneratorsError)basic_from_dict _sort_gens _unify_gens _dict_reorder_dict_from_expr_parallel_dict_from_expr)together)dup_isolate_real_roots_list)grouppublic filldedent)sympy_deprecation_warning)iterablesiftN) NoConvergencec.tfd}|S)Nct|}t|tr ||St|tr3|j|g|j d|j i}||St|tr' |j|g|j }||StS#t$r[|jrtcYSt|jj}||}|turtddd|cYSwxYw)Ndomaina@ Mixing Poly with non-polynomial expressions in binary operations is deprecated. Either explicitly convert the non-Poly operand to a Poly with as_poly() or convert the Poly to an Expr with as_expr(). z1.6z)deprecated-poly-nonpoly-binary-operations)deprecated_since_versionactive_deprecations_target)r# isinstancePolyr from_exprgensrPr r9 is_MatrixNotImplementedgetattras_expr__name__rJ)fg expr_methodresultfuncs Z/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/polys/polytools.pywrapperz_polifyit..wrapperEs QK a 1:  7 # A88qxx8A1:  4  "AKK+AFF+&Aqz!! !)# ;;))%aiik4==A $Q/- 273^  ! s:B&&D AD  D )r)r`rbs` ra _polifyitrcDs  4[""> NceZdZdZdZdZdZdZdZe dZ e dZ e dZ d Ze d Ze d Ze d Ze d Ze dZe dZe dZe dZe dZfdZe dZe dZe dZe dZe dZe dZe dZdZ dZ!ddZ"dZ#dZ$d Z%d!Z&d"Z'd#Z(dd$Z)d%Z*d&Z+d'Z,d(Z-d)Z.d*Z/d+Z0dd,Z1dd-Z2dd.Z3dd/Z4dd0Z5d1Z6d2Z7d3Z8d4Z9d5Z:dd6Z;dd7Zd:Z?d;Z@dd<ZAd=ZBd>ZCd?ZDd@ZEdAZFdBZGdCZHdDZIdEZJdFZKdGZLdHZMdIZNdJZOdKZPdLZQdMZRdNZSddOZTddPZUddQZVddRZWdSZXddTZYdUZZdVZ[dWZ\dXZ]ddYZ^dZZ_dd[Z`d\Zad]Zbdd^Zcdd_Zddd`ZeddaZfddbZgdcZhddZiddeZjdfZkdgZldhZmemZnddiZodjZpddkZqddlZrddmZsdnZtdoZuddpZvdqZwddrZxddsZydtZzduZ{dvZ|dwZ}ddxZ~dyZdzZd{Zd|Zd}Zd~ZdZddZdZdZdZdZddZddZdZdZddZddZddZddZddZddZddZdZdZdZddZdZddZe dZe dZe dZe dZe dZe dZe dZe dZe dZe dZe dZe dZe dZe dZdZdZedZedZedZedZedZedZededZedZedZedZedZedZedZededZededZededZededZdZddZddZdZÈxZS)rTaP Generic class for representing and operating on polynomial expressions. See :ref:`polys-docs` for general documentation. Poly is a subclass of Basic rather than Expr but instances can be converted to Expr with the :py:meth:`~.Poly.as_expr` method. .. deprecated:: 1.6 Combining Poly with non-Poly objects in binary operations is deprecated. Explicitly convert both objects to either Poly or Expr first. See :ref:`deprecated-poly-nonpoly-binary-operations`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y Create a univariate polynomial: >>> Poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') Create a univariate polynomial with specific domain: >>> from sympy import sqrt >>> Poly(x**2 + 2*x + sqrt(3), domain='R') Poly(1.0*x**2 + 2.0*x + 1.73205080756888, x, domain='RR') Create a multivariate polynomial: >>> Poly(y*x**2 + x*y + 1) Poly(x**2*y + x*y + 1, x, y, domain='ZZ') Create a univariate polynomial, where y is a constant: >>> Poly(y*x**2 + x*y + 1,x) Poly(y*x**2 + y*x + 1, x, domain='ZZ[y]') You can evaluate the above polynomial as a function of y: >>> Poly(y*x**2 + x*y + 1,x).eval(2) 6*y + 1 See Also ======== sympy.core.expr.Expr reprVTgn$@ctj||}d|vr tdt|tt t tfr|j||St|tr=t|tr|j||S|jt||St|t!|tu}|j"r|j%||S|j'||S)z:Create a new polynomial instance out of something useful. orderz&'order' keyword is not implemented yet)exclude)evaluate)options build_optionsNotImplementedErrorrSr1r2r3r,_from_domain_elementrKstrdict _from_dict _from_listlistr"typeis_Poly _from_poly _from_exprclsrgrVargsopts ra__new__z Poly.__new__s##D$/ c>%&NO O cCc=9 :++C5 5 c3 '#t$~~c3//~~d3i55#S (<=C{{~~c3//~~c3//rdct|tstd|z|jt |dz k7rtd|d|t j |}||_||_|S)z:Construct :class:`Poly` instance from raw representation. z%invalid polynomial representation: %szinvalid arguments: z, ) rSr1r9levlenr r}rgrV)rzrgrVobjs ranewzPoly.newsh#s#!7#=? ? WWD A %!d"KL LmmC  rdc^t|jjg|jSN)r?rg to_sympy_dictrVselfs raexprz Poly.exprs#txx557D$))DDrdc6|jf|jzSr)rrVrs rar{z Poly.argss |dii''rdc6|jf|jzSrrfrs ra_hashable_contentzPoly._hashable_contents{TYY&&rdcRtj||}|j||S)(Construct a polynomial from a ``dict``. )rlrmrrrys ra from_dictzPoly.from_dict'##D$/~~c3''rdcRtj||}|j||S)(Construct a polynomial from a ``list``. )rlrmrsrys ra from_listzPoly.from_listrrdcRtj||}|j||S)*Construct a polynomial from a polynomial. )rlrmrwrys ra from_polyzPoly.from_polyrrdcRtj||}|j||S+Construct a polynomial from an expression. )rlrmrxrys rarUzPoly.from_exprrrdc6|j}|s tdt|dz }|j}|t ||\}}n,|j D]\}}|j |||<|jtj|||g|S)rz0Cannot initialize from 'dict' without generatorsrr|) rVr8rrPr(itemsconvertrr1r)rzrgr|rVlevelrPmonomcoeffs rarrzPoly._from_dictsxx"BD DD A  >*3C8KFC #  3 u#^^E2E  3swws}}S%8@4@@rdcN|j}|s tdt|dk7r tdt|dz }|j}|t ||\}}nt t|j|}|jtj|||g|S)rz0Cannot initialize from 'list' without generatorsrz#'list' representation not supportedr) rVr8rr:rPr(rtmaprrr1r)rzrgr|rVrrPs rarszPoly._from_list sxx"BD D Y!^-57 7D A  >*3C8KFCs6>>3/0Cswws}}S%8@4@@rdc||jk7r'|j|jg|j}|j}|j}|j }|r_|j|k7rPt |jt |k7r |j|j|S|j|}d|vr|r|j|}|S|dur|j}|S)rrPT) __class__rrgrVfieldrPsetrxrZreorder set_domainto_field)rzrgr|rVrrPs rarwzPoly._from_poly!s #-- #''#''-CHH-Cxx  CHH$388}D )~~ckkmS99!ckk4( s?v..(C d],,.C rdcDt||\}}|j||Sr)rCrr)rzrgr|s rarxzPoly._from_expr8s%#3,S~~c3''rdc|j}|j}t|dz }|j|g}|jt j |||g|SNr)rVrPrrrr1r)rzrgr|rVrPrs rarozPoly._from_domain_element>sUxxD A ~~c"#swws}}S%8@4@@rdc t|Srsuper__hash__rrs rarz Poly.__hash__Hw!!rdct}|j}tt|D]0}|j D]}||s |||j z}02||j zS)a Free symbols of a polynomial expression. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 1).free_symbols {x} >>> Poly(x**2 + y).free_symbols {x, y} >>> Poly(x**2 + y, x).free_symbols {x, y} >>> Poly(x**2 + y, x, z).free_symbols {x, y} )rrVrangermonoms free_symbolsfree_symbols_in_domain)rsymbolsrVirs rarzPoly.free_symbolsKsr*%yys4y! A 8tAw333G   4444rdc|jjt}}|jr"|jD]}||j z}|S|j r$|jD]}||j z}|S)aj Free symbols of the domain of ``self``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1).free_symbols_in_domain set() >>> Poly(x**2 + y).free_symbols_in_domain set() >>> Poly(x**2 + y, x).free_symbols_in_domain {y} )rgdomr is_Compositerris_EXcoeffs)rrPrgenrs rarzPoly.free_symbols_in_domainjs&((,,   ~~ ,3+++ ,  \\ .5--- .rdc |jdS)z Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x rrVrs rarzPoly.gensyy|rdc"|jS)aGet the ground domain of a :py:class:`~.Poly` Returns ======= :py:class:`~.Domain`: Ground domain of the :py:class:`~.Poly`. Examples ======== >>> from sympy import Poly, Symbol >>> x = Symbol('x') >>> p = Poly(x**2 + x) >>> p Poly(x**2 + x, x, domain='ZZ') >>> p.domain ZZ ) get_domainrs rarPz Poly.domains*  rdc|j|jj|jj|jjg|j S)z3Return zero polynomial with ``self``'s properties. )rrgzerorrrVrs rarz Poly.zero=txx dhhllDHHLLANDIINNrdc|j|jj|jj|jjg|j S)z2Return one polynomial with ``self``'s properties. )rrgonerrrVrs rarzPoly.ones=txx TXX\\488<<@M499MMrdc|j|jj|jj|jjg|j S)z3Return unit polynomial with ``self``'s properties. )rrgunitrrrVrs rarz Poly.unitrrdcN|j|\}}}}||||fS)a Make ``f`` and ``g`` belong to the same domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f, g = Poly(x/2 + 1), Poly(2*x + 1) >>> f Poly(1/2*x + 1, x, domain='QQ') >>> g Poly(2*x + 1, x, domain='ZZ') >>> F, G = f.unify(g) >>> F Poly(1/2*x + 1, x, domain='QQ') >>> G Poly(2*x + 1, x, domain='QQ') )_unify)r\r]_perFGs raunifyz Poly.unifys+2xx{ 311vs1v~rdc bt|}|jsm |jjj |}|jj|j |j|jj |fSt|jtr.perL!GV}tFQJK'88<<,,3773&& &rd)r"rvrgr from_sympyr ground_newr6r7rSr1rArVrrrBto_dictrrrqrtzipr)r\r]g_coeffrVrrf_monomsf_coeffscrg_monomsg_coeffsrrrzs @rarz Poly._unifysX AJyy J%%))..q1uuyy!%%0@0@0III aeeS !j&<qvvqvv.Duuyyquuyy$7TQCvv~%2EEMMOQVVT&3"(5599#CKLa Aquuyy 9LHLMM$tC(,C'D"EsCPEEMM#&vv~%2EEMMOQVVT&3"(5599#CKLa Aquuyy 9LHLMM$tC(,C'D"EsCPEEMM#&#A$FG Gkk4 'CA~[" L'Q(JKK L M Ms%L -L'-L, L$c| |j}|5|d|||dzdz}|s%|jjj|S|jj |g|S)ab Create a Poly out of the given representation. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x, y >>> from sympy.polys.polyclasses import DMP >>> a = Poly(x**2 + 1) >>> a.per(DMP([ZZ(1), ZZ(1)], ZZ), gens=[y]) Poly(y + 1, y, domain='ZZ') Nr)rVrgrrrr)r\rgrVrs rarzPoly.persi$ <66D  =4 #44Duuyy))#..q{{s*T**rdctj|jd|i}|j|jj |j S)z Set the ground domain of ``f``. rP)rlrmrVrrgrrP)r\rPr|s rarzPoly.set_domain-s=##AFFXv,>?uuQUU]]3::.//rdc.|jjS)z Get the ground domain of ``f``. )rgrr\s rarzPoly.get_domain2suuyyrdcttjj|}|jt |S)z Set the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(5*x**2 + 2*x - 1, x).set_modulus(2) Poly(x**2 + 1, x, modulus=2) )rlModulus preprocessrr))r\moduluss ra set_moduluszPoly.set_modulus6s+//,,W5||BwK((rdc|j}|jrt|jSt d)z Get the modulus of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, modulus=2).get_modulus() 2 z$not a polynomial over a Galois field)ris_FiniteFieldrcharacteristicr9)r\rPs ra get_moduluszPoly.get_modulusGs8  60023 3!"HI Irdc||jvr1|jr|j||S |j||S|j j ||S#t$rY+wxYw)z)Internal implementation of :func:`subs`. )rV is_numberevalreplacer9rZsubs)r\oldrs ra _eval_subszPoly._eval_subs\sj !&&=}}vvc3''99S#..yy{S))'sA A,+A,c|jj\}}t|jDcgc] \}}||vs |}}}|j ||Scc}}w)a  Remove unnecessary generators from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import a, b, c, d, x >>> Poly(a + x, a, b, c, d, x).exclude() Poly(a + x, a, x, domain='ZZ') r)rgrj enumeraterVr)r\JrjrrVs rarjz Poly.excludeisV3"+AFF"3B3qzBBuuStu$$Cs AAc |&|jr|j|}}n td||k(s||jvr|S||jvr~||jvrp|j }|j r||j vrFt|j}|||j|<|j|j|Std|d|d|)a Replace ``x`` with ``y`` in generators list. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 1, x).replace(x, y) Poly(y**2 + 1, y, domain='ZZ') z(syntax supported only in univariate caserzCannot replace r in ) is_univariaterr9rVrrrrtindexrrg)r\xy_ignorerrVs rarz Poly.replace|s 9uua1%>@@ 6Qaff_H ;1AFF?,,.C##q ';AFF|&'TZZ]#uuQUUu..1aKLLrdcB|jj|i|S)z-Match expression from Poly. See Basic.match())rZmatch)r\r{kwargss rarz Poly.matchs  qyy{  $1&11rdc tjd|}|st|j|}n,t |jt |k7r t dt ttt|jj|j|}|jtj|t|dz |jj |S)a Efficiently apply new order of generators. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y**2, x, y).reorder(y, x) Poly(y**2*x + x**2, y, x, domain='ZZ') rz7generators list can differ only up to order of elementsrr)rlOptionsr@rVrr9rqrtrrBrgrrr1rrr)r\rVr{r|rgs rarz Poly.reordersoob$'aff#.D [CI %!IK K4]155==?AFFDIJKLuuS]]3D A quuyyAuMMrdcr|jd}|j|}i}|jD])\}}t|d|rt d|z||||d<+|j |d}|j tj|t|dz |jjg|S)a( Remove dummy generators from ``f`` that are to the left of specified ``gen`` in the generators as ordered. When ``gen`` is an integer, it refers to the generator located at that position within the tuple of generators of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(y**2 + y*z**2, x, y, z).ltrim(y) Poly(y**2 + y*z**2, y, z, domain='ZZ') >>> Poly(z, x, y, z).ltrim(-1) Poly(z, z, domain='ZZ') T)nativeNzCannot left trim %sr) as_dict _gen_to_levelranyr9rVrr1rrrgr)r\rrgrtermsrrrVs raltrimz Poly.ltrims&iiti$ OOC IIK %LE55!9~%&;a&?@@$E%)   %vvabzquuS]]5#d)a-CKdKKrdc t}|D]/} |jj|}|j|1|j D]}t|D]\}}||vs |sy!y#t$rt |d|dwxYw)aJ Return ``True`` if ``Poly(f, *gens)`` retains ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x*y + 1, x, y, z).has_only_gens(x, y) True >>> Poly(x*y + z, x, y, z).has_only_gens(x, y) False  doesn't have as generatorFT)rrVradd ValueErrorr>rr)r\rVindicesrrrrelts ra has_only_genszPoly.has_only_genss % #C # S)  E" #XXZ !E#E* !3G#  ! !  B%9:C@BB Bs A22B ct|jdr|jj}n t|d|j |S)z Make the ground domain a ring. Examples ======== >>> from sympy import Poly, QQ >>> from sympy.abc import x >>> Poly(x**2 + 1, domain=QQ).to_ring() Poly(x**2 + 1, x, domain='ZZ') to_ring)hasattrrgrr4rr\r_s rarz Poly.to_rings< 155) $UU]]_F'95 5uuV}rdct|jdr|jj}n t|d|j |S)z Make the ground domain a field. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(x**2 + 1, x, domain=ZZ).to_field() Poly(x**2 + 1, x, domain='QQ') r)rrgrr4rrs rarz Poly.to_field= 155* %UU^^%F':6 6uuV}rdct|jdr|jj}n t|d|j |S)z Make the ground domain exact. Examples ======== >>> from sympy import Poly, RR >>> from sympy.abc import x >>> Poly(x**2 + 1.0, x, domain=RR).to_exact() Poly(x**2 + 1, x, domain='QQ') to_exact)rrgr r4rrs rar z Poly.to_exact-rrdct|jd||jjxsd\}}|j ||j |S)a Recalculate the ground domain of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x, domain='QQ[y]') >>> f Poly(x**2 + 1, x, domain='QQ[y]') >>> f.retract() Poly(x**2 + 1, x, domain='ZZ') >>> f.retract(field=True) Poly(x**2 + 1, x, domain='QQ') TrN)r compositerP)r(r rPrrrV)r\rrrgs raretractz Poly.retractBsM($AII4I$8188#8#8#@DBS{{3s{33rdc|d||}}}n|j|}t|t|}}t|jdr|jj |||}n t |d|j |S)z1Take a continuous subsequence of terms of ``f``. rslice)r intrrgr'r4r)r\rmnrr_s rar'z Poly.sliceZsr 9A!qA"A1vs1v1 155' "UU[[Aq)F'73 3uuV}rdc|jj|Dcgc]'}|jjj|)c}Scc}w)aQ Returns all non-zero coefficients from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x + 3, x).coeffs() [1, 2, 3] See Also ======== all_coeffs coeff_monomial nth ri)rgrrr)r\rirs rarz Poly.coeffsjs:(01uu||%|/HI! ""1%IIIs,Ac:|jj|S)aU Returns all non-zero monomials from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).monoms() [(2, 0), (1, 2), (1, 1), (0, 1)] See Also ======== all_monoms r,)rgrr\ris rarz Poly.monomss$uu||%|((rdc|jj|Dcgc],\}}||jjj|f.c}}Scc}}w)ac Returns all non-zero terms from ``f`` in lex order. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).terms() [((2, 0), 1), ((1, 2), 2), ((1, 1), 1), ((0, 1), 3)] See Also ======== all_terms r,)rgrrr)r\rir)rs rarz Poly.termssC$89uu{{{7OPtq!AEEII&&q)*PPPs1Ac|jjDcgc]'}|jjj|)c}Scc}w)a Returns all coefficients from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_coeffs() [1, 0, 2, -1] )rg all_coeffsrr)r\rs rar1zPoly.all_coeffss801uu/?/?/AB! ""1%BBBs,A c6|jjS)a? Returns all monomials from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_monoms() [(3,), (2,), (1,), (0,)] See Also ======== all_terms )rg all_monomsrs rar3zPoly.all_monomss$uu!!rdc|jjDcgc],\}}||jjj|f.c}}Scc}}w)a Returns all terms from a univariate polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x - 1, x).all_terms() [((3,), 1), ((2,), 0), ((1,), 2), ((0,), -1)] )rg all_termsrr)r\r)rs rar5zPoly.all_termss?89uu7HItq!AEEII&&q)*IIIs1Aci}|jD]@\}}|||}t|tr|\}}n|}|s*||vr|||<4td|z|j|g|xs |j i|S)ah Apply a function to all terms of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> def func(k, coeff): ... k = k[0] ... return coeff//10**(2-k) >>> Poly(x**2 + 20*x + 400).termwise(func) Poly(x**2 + 2*x + 4, x, domain='ZZ') z%s monomial was generated twice)rrStupler9rrV)r\r`rVr{rrrr_s ratermwisez Poly.termwises$GGI CLE5%'F&%(% u%#(E%L)9EACC Cq{{5>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x - 1).length() 3 )rr rs ralengthz Poly.lengths199;rdcv|r|jj|S|jj|S)a Switch to a ``dict`` representation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x*y**2 - y, x, y).as_dict() {(0, 1): -1, (1, 2): 2, (2, 0): 1} r")rgrr)r\r rs rar z Poly.as_dicts4 55==d=+ +55&&D&1 1rdcn|r|jjS|jjS)z%Switch to a ``list`` representation. )rgto_list to_sympy_list)r\r s raas_listz Poly.as_list$s( 55==? "55&&( (rdcv|s |jSt|dk(r\t|dtrI|d}t |j }|j D]\}} |j|}|||<t|jjg|S#t$rt|d|dwxYw)ar Convert a Poly instance to an Expr instance. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2 + 2*x*y**2 - y, x, y) >>> f.as_expr() x**2 + 2*x*y**2 - y >>> f.as_expr({x: 5}) 10*y**2 - y + 25 >>> f.as_expr(5, 6) 379 rrrr) rrrSrqrtrVrrrr>r?rgr)r\rVmappingrvaluers rarZz Poly.as_expr+s(66M t9>ja$71gGDFFFs !BB8c^ t|g|i|}|jsy|S#t$rYywxYw)a{Converts ``self`` to a polynomial or returns ``None``. >>> from sympy import sin >>> from sympy.abc import x, y >>> print((x**2 + x*y).as_poly()) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + x*y).as_poly(x, y)) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + sin(y)).as_poly(x, y)) None N)rTrvr9)rrVr{polys raas_polyz Poly.as_polyQs<  ,t,t,D<<   s  ,,ct|jdr|jj}n t|d|j |S)a Convert algebraic coefficients to rationals. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**2 + I*x + 1, x, extension=I).lift() Poly(x**4 + 3*x**2 + 1, x, domain='QQ') lift)rrgrGr4rrs rarGz Poly.liftks< 155& !UUZZ\F'62 2uuV}rdct|jdr|jj\}}n t|d||j |fS)a+ Reduce degree of ``f`` by mapping ``x_i**m`` to ``y_i``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3 + 1, x, y).deflate() ((3, 2), Poly(x**2*y + x + 1, x, y, domain='ZZ')) deflate)rrgrIr4rr\rr_s rarIz Poly.deflatesE 155) $ IAv'95 5!%%-rdc|jj}|jr|S|jst d|zt |jdr|jj |}n t|d|r|j|jz}n|j|jz}|j|g|S)a Inject ground domain generators into ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x) >>> f.inject() Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ') >>> f.inject(front=True) Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ') z Cannot inject generators over %sinjectfront) rgr is_Numericalrvr5rrLr4rrVr)r\rNrr_rVs rarLz Poly.injects$eeii   H@3FG G 155( #UU\\\.F'84 4 ;;'D66CKK'DquuV#d##rdc|jj}|jstd|zt |}|j d||k(r|j |dd}}n1|j | d|k(r|j d| d}}n t d|j|}t|jdr|jj||}n t|d|j|g|S)a Eject selected generators into the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y) >>> f.eject(x) Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]') >>> f.eject(y) Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]') zCannot eject generators over %sNTFz'can only eject front or back generatorsejectrM) rgrrOr5rrVrnrLrrQr4r)r\rVrk_gensrNr_s rarQz Poly.ejects$eeii?#EF F I 66"1: 66!":t5E VVQBC[D 66#A2;5E%9; ;cjj$ 155' "UU[[E[2F'73 3quuV$e$$rdct|jdr|jj\}}n t|d||j |fS)a Remove GCD of terms from the polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**6*y**2 + x**3*y, x, y).terms_gcd() ((3, 1), Poly(x**3*y + 1, x, y, domain='ZZ')) terms_gcd)rrgrUr4rrJs rarUzPoly.terms_gcdsF 155+ &)IAv';7 7!%%-rdct|jdr|jj|}n t|d|j |S)z Add an element of the ground domain to ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).add_ground(2) Poly(x + 3, x, domain='ZZ') add_ground)rrgrWr4rr\rr_s rarWzPoly.add_groundA 155, 'UU%%e,F'<8 8uuV}rdct|jdr|jj|}n t|d|j |S)z Subtract an element of the ground domain from ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).sub_ground(2) Poly(x - 1, x, domain='ZZ') sub_ground)rrgr[r4rrXs rar[zPoly.sub_groundrYrdct|jdr|jj|}n t|d|j |S)z Multiply ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 1).mul_ground(2) Poly(2*x + 2, x, domain='ZZ') mul_ground)rrgr]r4rrXs rar]zPoly.mul_ground#rYrdct|jdr|jj|}n t|d|j |S)aO Quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).quo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).quo_ground(2) Poly(x + 1, x, domain='ZZ') quo_ground)rrgr_r4rrXs rar_zPoly.quo_ground8sA" 155, 'UU%%e,F'<8 8uuV}rdct|jdr|jj|}n t|d|j |S)a Exact quotient of ``f`` by a an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x + 4).exquo_ground(2) Poly(x + 2, x, domain='ZZ') >>> Poly(2*x + 3).exquo_ground(2) Traceback (most recent call last): ... ExactQuotientFailed: 2 does not divide 3 in ZZ exquo_ground)rrgrar4rrXs rarazPoly.exquo_groundPsA& 155. )UU''.F'>: :uuV}rdct|jdr|jj}n t|d|j |S)z Make all coefficients in ``f`` positive. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).abs() Poly(x**2 + 1, x, domain='ZZ') abs)rrgrcr4rrs rarczPoly.absjs< 155% UUYY[F'51 1uuV}rdct|jdr|jj}n t|d|j |S)a4 Negate all coefficients in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).neg() Poly(-x**2 + 1, x, domain='ZZ') >>> -Poly(x**2 - 1, x) Poly(-x**2 + 1, x, domain='ZZ') neg)rrgrer4rrs rarezPoly.neg<" 155% UUYY[F'51 1uuV}rdct|}|js|j|S|j|\}}}}t |j dr|j |}n t|d||S)a[ Add two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).add(Poly(x - 2, x)) Poly(x**2 + x - 1, x, domain='ZZ') >>> Poly(x**2 + 1, x) + Poly(x - 2, x) Poly(x**2 + x - 1, x, domain='ZZ') r)r"rvrWrrrgrr4r\r]rrrrr_s rarzPoly.addi" AJyy<<? "xx{ 31 155% UU1XF'51 16{rdct|}|js|j|S|j|\}}}}t |j dr|j |}n t|d||S)a` Subtract two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).sub(Poly(x - 2, x)) Poly(x**2 - x + 3, x, domain='ZZ') >>> Poly(x**2 + 1, x) - Poly(x - 2, x) Poly(x**2 - x + 3, x, domain='ZZ') sub)r"rvr[rrrgrkr4rhs rarkzPoly.subrirdct|}|js|j|S|j|\}}}}t |j dr|j |}n t|d||S)ap Multiply two polynomials ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') >>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ') r)r"rvr]rrrgrr4rhs rarzPoly.mulrirdct|jdr|jj}n t|d|j |S)a3 Square a polynomial ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).sqr() Poly(x**2 - 4*x + 4, x, domain='ZZ') >>> Poly(x - 2, x)**2 Poly(x**2 - 4*x + 4, x, domain='ZZ') sqr)rrgrnr4rrs rarnzPoly.sqrrfrdct|}t|jdr|jj|}n t |d|j |S)aX Raise ``f`` to a non-negative power ``n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x - 2, x).pow(3) Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') >>> Poly(x - 2, x)**3 Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ') pow)r(rrgrpr4rr\r*r_s rarpzPoly.pow sG" F 155% UUYYq\F'51 1uuV}rdc|j|\}}}}t|jdr|j|\}}n t |d||||fS)a# Polynomial pseudo-division of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pdiv(Poly(2*x - 4, x)) (Poly(2*x + 4, x, domain='ZZ'), Poly(20, x, domain='ZZ')) pdiv)rrrgrsr4)r\r]rrrrqrs rarsz Poly.pdiv&sWxx{ 31 155& !66!9DAq'62 21vs1v~rdc|j|\}}}}t|jdr|j|}n t |d||S)aN Polynomial pseudo-remainder of ``f`` by ``g``. Caveat: The function prem(f, g, x) can be safely used to compute in Z[x] _only_ subresultant polynomial remainder sequences (prs's). To safely compute Euclidean and Sturmian prs's in Z[x] employ anyone of the corresponding functions found in the module sympy.polys.subresultants_qq_zz. The functions in the module with suffix _pg compute prs's in Z[x] employing rem(f, g, x), whereas the functions with suffix _amv compute prs's in Z[x] employing rem_z(f, g, x). The function rem_z(f, g, x) differs from prem(f, g, x) in that to compute the remainder polynomials in Z[x] it premultiplies the divident times the absolute value of the leading coefficient of the divisor raised to the power degree(f, x) - degree(g, x) + 1. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).prem(Poly(2*x - 4, x)) Poly(20, x, domain='ZZ') prem)rrrgrwr4rhs rarwz Poly.prem=sK<xx{ 31 155& !VVAYF'62 26{rdc|j|\}}}}t|jdr|j|}n t |d||S)a Polynomial pseudo-quotient of ``f`` by ``g``. See the Caveat note in the function prem(f, g). Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).pquo(Poly(2*x - 4, x)) Poly(2*x + 4, x, domain='ZZ') >>> Poly(x**2 - 1, x).pquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') pquo)rrrgryr4rhs raryz Poly.pquodsK&xx{ 31 155& !VVAYF'62 26{rdc&|j|\}}}}t|jdr |j|}n t|d||S#t$r3}|j |j |j d}~wwxYw)a Polynomial exact pseudo-quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).pexquo(Poly(2*x - 2, x)) Poly(2*x + 2, x, domain='ZZ') >>> Poly(x**2 + 1, x).pexquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 pexquoN)rrrgr{r;rrZr4)r\r]rrrrr_excs rar{z Poly.pexquos&xx{ 31 155( # 8!(84 46{ ' 8ggaiik199;77 8sA B.B  Bc|j|\}}}}d}|r:|jr.|js"|j|j}}d}t |j dr|j |\}} n t|d|r% |j| j} } | | } }|||| fS#t$rYwxYw)a Polynomial division with remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x)) (Poly(1/2*x + 1, x, domain='QQ'), Poly(5, x, domain='QQ')) >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x), auto=False) (Poly(0, x, domain='ZZ'), Poly(x**2 + 1, x, domain='ZZ')) FTdiv) ris_Ringis_Fieldrrrgr~r4rr6) r\r]autorrrrr%rtruQRs rar~zPoly.divs"!S!Q CKK ::<qAG 155% 558DAq'51 1  yy{AIIK1!11vs1v~ "  s C CCcf|j|\}}}}d}|r:|jr.|js"|j|j}}d}t |j dr|j |}n t|d|r |j}||S#t$rYwxYw)ao Computes the polynomial remainder of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x)) Poly(5, x, domain='ZZ') >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x), auto=False) Poly(x**2 + 1, x, domain='ZZ') FTrem) rrrrrrgrr4rr6) r\r]rrrrrr%rus rarzPoly.rem"!S!Q CKK ::<qAG 155% aA'51 1  IIK1v "   B$$ B0/B0cf|j|\}}}}d}|r:|jr.|js"|j|j}}d}t |j dr|j |}n t|d|r |j}||S#t$rYwxYw)aa Computes polynomial quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x)) Poly(1/2*x + 1, x, domain='QQ') >>> Poly(x**2 - 1, x).quo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') FTquo) rrrrrrgrr4rr6) r\r]rrrrrr%rts rarzPoly.quorrc|j|\}}}}d}|r:|jr.|js"|j|j}}d}t |j dr |j |}n t|d|r |j}||S#t$r3} | j|j|jd} ~ wwxYw#t$rYRwxYw)a Computes polynomial exact quotient of ``f`` by ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).exquo(Poly(x - 1, x)) Poly(x + 1, x, domain='ZZ') >>> Poly(x**2 + 1, x).exquo(Poly(2*x - 4, x)) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 FTexquoN) rrrrrrgrr;rrZr4rr6) r\r]rrrrrr%rtr|s rarz Poly.exquos&!S!Q CKK ::<qAG 155' " 8GGAJ(73 3  IIK1v ' 8ggaiik199;77 8"  s*,B% C$% C!..CC!$ C0/C0c*t|trDt|j}| |cxkr|krnn |dkr||zS|St d|d|d| |jj t |S#t$rt d|zwxYw)z3Returns level associated with the given generator. r-z <= gen < z expected, got z"a valid generator expected, got %s)rSr(rrVr9rr"r)r\rr:s rar zPoly._gen_to_level:s c3 [Fw#&&7!C<'J%'-vs'<== @vv||GCL11 @%83>@@ @s #A::Bc|j|}t|jdr2|jj|}|dkrtj }|St |d)au Returns degree of ``f`` in ``x_j``. The degree of 0 is negative infinity. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree() 2 >>> Poly(x**2 + y*x + y, x, y).degree(y) 1 >>> Poly(0, x).degree() -oo degreer)r rrgrrNegativeInfinityr4)r\rrds rarz Poly.degreeNsU( OOC  155( # QA1u&&H'84 4rdczt|jdr|jjSt|d)z Returns a list of degrees of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).degree_list() (2, 1) degree_list)rrgrr4rs rarzPoly.degree_listls2 155- (55$$& &'=9 9rdczt|jdr|jjSt|d)a Returns the total degree of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + y*x + 1, x, y).total_degree() 2 >>> Poly(x + y**5, x, y).total_degree() 5 total_degree)rrgrr4rs rarzPoly.total_degrees2 155. )55%%' ''>: :rdct|tstdt|z||jvr(|jj |}|j}n%t |j}|j|fz}t|jdr,|j|jj||St|d)a Returns the homogeneous polynomial of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(x**5 + 2*x**2*y**2 + 9*x*y**3) >>> f.homogenize(z) Poly(x**5 + 2*x**2*y**2*z + 9*x*y**3*z, x, y, z, domain='ZZ') z``Symbol`` expected, got %s homogenizerhomogeneous_order) rSr! TypeErrorrurVrrrrgrrr4)r\srrVs rarzPoly.homogenizes,!V$9DGCD D ; QA66DAFF A66QD=D 155, '55))!,458 8#A':;;rdczt|jdr|jjSt|d)a- Returns the homogeneous order of ``f``. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. This degree is the homogeneous order of ``f``. If you only want to check if a polynomial is homogeneous, then use :func:`Poly.is_homogeneous`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4) >>> f.homogeneous_order() 5 r)rrgrr4rs rarzPoly.homogeneous_orders4( 155- .55**, ,'+>? ?rdc||j|dSt|jdr|jj}n t |d|jj j |S)z Returns the leading coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(4*x**3 + 2*x**2 + 3*x, x).LC() 4 rLC)rrrgrr4rr)r\rir_s rarzPoly.LCs`  88E?1% % 155$ UUXXZF'40 0uuyy!!&))rdct|jdr|jj}n t|d|jjj |S)z Returns the trailing coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).TC() 0 TC)rrgrr4rrrs rarzPoly.TCsG 155$ UUXXZF'40 0uuyy!!&))rdcnt|jdr|j|dSt|d)z Returns the last non-zero coefficient of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 + 2*x**2 + 3*x, x).EC() 3 rEC)rrgrr4r.s rarzPoly.ECs2 155( #88E?2& &'40 0rdc\|jt||jjS)aE Returns the coefficient of ``monom`` in ``f`` if there, else None. Examples ======== >>> from sympy import Poly, exp >>> from sympy.abc import x, y >>> p = Poly(24*x*y*exp(8) + 23*x, x, y) >>> p.coeff_monomial(x) 23 >>> p.coeff_monomial(y) 0 >>> p.coeff_monomial(x*y) 24*exp(8) Note that ``Expr.coeff()`` behaves differently, collecting terms if possible; the Poly must be converted to an Expr to use that method, however: >>> p.as_expr().coeff(x) 24*y*exp(8) + 23 >>> p.as_expr().coeff(y) 24*x*exp(8) >>> p.as_expr().coeff(x*y) 24*exp(8) See Also ======== nth: more efficient query using exponents of the monomial's generators )nthr/rV exponents)r\rs racoeff_monomialzPoly.coeff_monomials'Fquuhuaff-7788rdcJt|jdr]t|t|jk7r t d|jj t tt|}n t|d|jjj|S)a. Returns the ``n``-th coefficient of ``f`` where ``N`` are the exponents of the generators in the term of interest. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x, y >>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2) 2 >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2) 2 >>> Poly(4*sqrt(x)*y) Poly(4*y*(sqrt(x)), y, sqrt(x), domain='ZZ') >>> _.nth(1, 1) 4 See Also ======== coeff_monomial rz,exponent of each generator must be specified) rrgrrVrrrtrr(r4rr)r\Nr_s rarzPoly.nth4sw2 155% 1vQVV$ !OPPQUUYYSa[ 12F'51 1uuyy!!&))rdctd)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.rn)r\rr*rights rarz Poly.coeffVs" 01 1rdcRt|j|d|jS)a Returns the leading monomial of ``f``. The Leading monomial signifies the monomial having the highest power of the principal generator in the expression f. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LM() x**2*y**0 rr/rrVr.s raLMzPoly.LMbs"$*AFF33rdcRt|j|d|jS)z Returns the last non-zero monomial of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM() x**0*y**1 rrr.s raEMzPoly.EMvs"+QVV44rdc`|j|d\}}t||j|fS)a Returns the leading term of ``f``. The Leading term signifies the term having the highest power of the principal generator in the expression f along with its coefficient. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LT() (x**2*y**0, 4) rrr/rVr\rirrs raLTzPoly.LTs0$wwu~a( uqvv&--rdc`|j|d\}}t||j|fS)z Returns the last non-zero term of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET() (x**0*y**1, 3) rrrs raETzPoly.ETs0wwu~b) uqvv&--rdct|jdr|jj}n t|d|jjj |S)z Returns maximum norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).max_norm() 3 max_norm)rrgrr4rrrs rarz Poly.max_normsH 155* %UU^^%F':6 6uuyy!!&))rdct|jdr|jj}n t|d|jjj |S)z Returns l1 norm of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(-x**2 + 2*x - 3, x).l1_norm() 6 l1_norm)rrgrr4rrrs rarz Poly.l1_normG 155) $UU]]_F'95 5uuyy!!&))rdc|}|jjjstj|fS|j }|j r$|jjj}t|jdr|jj\}}n t|d|j||j|}}|r |j s||fS||jfS)a Clear denominators, but keep the ground domain. Examples ======== >>> from sympy import Poly, S, QQ >>> from sympy.abc import x >>> f = Poly(x/2 + S(1)/3, x, domain=QQ) >>> f.clear_denoms() (6, Poly(3*x + 2, x, domain='QQ')) >>> f.clear_denoms(convert=True) (6, Poly(3*x + 2, x, domain='ZZ')) clear_denoms)rgrrrOnerhas_assoc_Ringget_ringrrr4rrr)rrr\rrr_s rarzPoly.clear_denomss$ uuyy!!55!8Olln   %%))$$&C 155. )EE..0ME6'>: :<<&f qc00!8O!))+% %rdc*|}|j|\}}}}||}||}|jr |js||fS|jd\}}|jd\}}|j |}|j |}||fS)a Clear denominators in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = Poly(x**2/y + 1, x) >>> g = Poly(x**3 + y, x) >>> p, q = f.rat_clear_denoms(g) >>> p Poly(x**2 + y, x, domain='ZZ[y]') >>> q Poly(y*x**3 + y**2, x, domain='ZZ[y]') Tr)rrrrr])rr]r\rrabs rarat_clear_denomszPoly.rat_clear_denomss* !S!Q F F !3!3a4K~~d~+1~~d~+1 LLO LLO!t rdc|}|jddr0|jjjr|j }t |jdr|s+|j |jjdS|j}|D]F}t|tr|\}}n|d}}|jt||j|}H|j |St|d)a Computes indefinite integral of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).integrate() Poly(1/3*x**3 + x**2 + x, x, domain='QQ') >>> Poly(x*y**2 + x, x, y).integrate((0, 1), (1, 0)) Poly(1/2*x**2*y**2 + 1/2*x**2, x, y, domain='QQ') rT integraterr)) getrgrrrrrrrSr7r(r r4)rspecsr{r\rgspecrr)s rarzPoly.integrate$ s"  88FD !aeeii&7&7 A 155+ &uuQUU__q_122%%C BdE*!FC!1CmmCFAOOC,@A  B55: ';7 7rdc|jddst|g|i|St|jdr|s+|j |jj dS|j}|D]F}t |tr|\}}n|d}}|j t||j|}H|j |St|d)aX Computes partial derivative of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + 2*x + 1, x).diff() Poly(2*x + 2, x, domain='ZZ') >>> Poly(x*y**2 + x, x, y).diff((0, 0), (1, 1)) Poly(2*x*y, x, y, domain='ZZ') rkTdiffrr) rrrrgrrrSr7r(r r4)r\rrrgrrr)s rarz Poly.diffL s"zz*d+a2%262 2 155& !uuQUUZZ!Z_--%%C =dE*!FC!1Chhs1vqs';<  =55: '62 2rdc|}|t|tr.|}|jD]\}}|j||}|St|tt fr`|}t |t |jkDr tdt|j|D]\}}|j||}|Sd|}} n|j|} t|jds t|d |jj|| } |j-| | S#t$r|s%td|d|jj t#|g\} \}|j%j'| |j} |j)| }| j+|| }|jj|| } YwxYw)a Evaluate ``f`` at ``a`` in the given variable. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> Poly(x**2 + 2*x + 3, x).eval(2) 11 >>> Poly(2*x*y + 3*x + y + 2, x, y).eval(x, 2) Poly(5*y + 8, y, domain='ZZ') >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f.eval({x: 2}) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f.eval({x: 2, y: 5}) Poly(2*z + 31, z, domain='ZZ') >>> f.eval({x: 2, y: 5, z: 7}) 45 >>> f.eval((2, 5)) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') ztoo many values providedrrzCannot evaluate at rr)rSrqrrr7rtrrVrrr rrgr4r6r5rr(runify_with_symbolsrrr) rrrrr\rArrBvaluesrr_a_domain new_domains rarz Poly.evalt s>  9!T"")--/+JCsE*A+At}-v;QVV,$%?@@"%afff"5+JCsE*A+!1"Aquuf%'62 2 *UUZZ1%FuuVAu&& *!1aeeii"PQQ 0! 5 #1\\^>>xP LL,&&q(3Aq) *s2D!!B*G Gc$|j|S)az Evaluate ``f`` at the give values. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y, z >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z) >>> f(2) Poly(5*y + 2*z + 6, y, z, domain='ZZ') >>> f(2, 5) Poly(2*z + 31, z, domain='ZZ') >>> f(2, 5, 7) 45 )r)r\rs ra__call__z Poly.__call__ s(vvf~rdc|j|\}}}}|r,|jr |j|j}}t|jdr|j |\}}n t |d||||fS)a Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).half_gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) half_gcdex)rrrrrgrr4) r\r]rrrrrrhs rarzPoly.half_gcdex su&!S!Q CKK::<qA 155, '<<?DAq'<8 81vs1v~rdc(|j|\}}}}|r,|jr |j|j}}t|jdr|j |\}}} n t |d|||||| fS)a Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15 >>> g = x**3 + x**2 - 4*x - 4 >>> Poly(f).gcdex(Poly(g)) (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(1/5*x**2 - 6/5*x + 2, x, domain='QQ'), Poly(x + 1, x, domain='QQ')) gcdex)rrrrrgrr4) r\r]rrrrrrtrs rarz Poly.gcdex s~*!S!Q CKK::<qA 155' "ggajGAq!'73 31vs1vs1v%%rdc|j|\}}}}|r,|jr |j|j}}t|jdr|j |}n t |d||S)a Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).invert(Poly(2*x - 1, x)) Poly(-4/3, x, domain='QQ') >>> Poly(x**2 - 1, x).invert(Poly(x - 1, x)) Traceback (most recent call last): ... NotInvertible: zero divisor invert)rrrrrgrr4)r\r]rrrrrr_s rarz Poly.invert si&!S!Q CKK::<qA 155( #XXa[F'84 46{rdct|jdr%|jjt|}n t |d|j |S)ad Compute ``f**(-1)`` mod ``x**n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(1, x).revert(2) Poly(1, x, domain='ZZ') >>> Poly(1 + x, x).revert(1) Poly(1, x, domain='ZZ') >>> Poly(x**2 - 2, x).revert(2) Traceback (most recent call last): ... NotReversible: only units are reversible in a ring >>> Poly(1/x, x).revert(1) Traceback (most recent call last): ... PolynomialError: 1/x contains an element of the generators set revert)rrgrr(r4rrqs rarz Poly.revert4 sC6 155( #UU\\#a&)F'84 4uuV}rdc|j|\}}}}t|jdr|j|}n t |dt t ||S)ad Computes the subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).subresultants(Poly(x**2 - 1, x)) [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')] subresultants)rrrgrr4rtrrhs rarzPoly.subresultantsV sT xx{ 31 155/ *__Q'F'?; ;CV$%%rdc|j|\}}}}t|jdr+|r|j||\}}n|j|}n t |d|r||dt t |fS||dS)a Computes the resultant of ``f`` and ``g`` via PRS. If includePRS=True, it includes the subresultant PRS in the result. Because the PRS is used to calculate the resultant, this is more efficient than calling :func:`subresultants` separately. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**2 + 1, x) >>> f.resultant(Poly(x**2 - 1, x)) 4 >>> f.resultant(Poly(x**2 - 1, x), includePRS=True) (4, [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'), Poly(-2, x, domain='ZZ')]) resultant includePRSrr)rrrgrr4rtr) r\r]rrrrrr_rs rarzPoly.resultanto s.xx{ 31 155+ &KKjKA Q';7 7 q)4C +<= =6!$$rdct|jdr|jj}n t|d|j |dS)z Computes the discriminant of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x + 3, x).discriminant() -8 discriminantrr)rrgrr4rrs rarzPoly.discriminant sD 155. )UU'')F'>: :uuVAu&&rdc ddlm}|||S)aCompute the *dispersion set* of two polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion set `\operatorname{J}(f, g)` is defined as: .. math:: \operatorname{J}(f, g) & := \{a \in \mathbb{N}_0 | \gcd(f(x), g(x+a)) \neq 1\} \\ & = \{a \in \mathbb{N}_0 | \deg \gcd(f(x), g(x+a)) \geq 1\} For a single polynomial one defines `\operatorname{J}(f) := \operatorname{J}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersion References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ r) dispersionset)sympy.polys.dispersionr)r\r]rs rarzPoly.dispersionset sP 9Q""rdc ddlm}|||S)aCompute the *dispersion* of polynomials. For two polynomials `f(x)` and `g(x)` with `\deg f > 0` and `\deg g > 0` the dispersion `\operatorname{dis}(f, g)` is defined as: .. math:: \operatorname{dis}(f, g) & := \max\{ J(f,g) \cup \{0\} \} \\ & = \max\{ \{a \in \mathbb{N} | \gcd(f(x), g(x+a)) \neq 1\} \cup \{0\} \} and for a single polynomial `\operatorname{dis}(f) := \operatorname{dis}(f, f)`. Examples ======== >>> from sympy import poly >>> from sympy.polys.dispersion import dispersion, dispersionset >>> from sympy.abc import x Dispersion set and dispersion of a simple polynomial: >>> fp = poly((x - 3)*(x + 3), x) >>> sorted(dispersionset(fp)) [0, 6] >>> dispersion(fp) 6 Note that the definition of the dispersion is not symmetric: >>> fp = poly(x**4 - 3*x**2 + 1, x) >>> gp = fp.shift(-3) >>> sorted(dispersionset(fp, gp)) [2, 3, 4] >>> dispersion(fp, gp) 4 >>> sorted(dispersionset(gp, fp)) [] >>> dispersion(gp, fp) -oo Computing the dispersion also works over field extensions: >>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ') >>> sorted(dispersionset(fp, gp)) [2] >>> sorted(dispersionset(gp, fp)) [1, 4] We can even perform the computations for polynomials having symbolic coefficients: >>> from sympy.abc import a >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x) >>> sorted(dispersionset(fp)) [0, 1] See Also ======== dispersionset References ========== 1. [ManWright94]_ 2. [Koepf98]_ 3. [Abramov71]_ 4. [Man93]_ r) dispersion)rr)r\r]rs rarzPoly.dispersion sP 6!Qrdc|j|\}}}}t|jdr|j|\}}}n t |d||||||fS)a# Returns the GCD of ``f`` and ``g`` and their cofactors. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).cofactors(Poly(x**2 - 3*x + 2, x)) (Poly(x - 1, x, domain='ZZ'), Poly(x + 1, x, domain='ZZ'), Poly(x - 2, x, domain='ZZ')) cofactors)rrrgrr4) r\r]rrrrrcffcfgs rarzPoly.cofactors? s`(xx{ 31 155+ &++a.KAsC';7 71vs3xS))rdc|j|\}}}}t|jdr|j|}n t |d||S)a  Returns the polynomial GCD of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).gcd(Poly(x**2 - 3*x + 2, x)) Poly(x - 1, x, domain='ZZ') gcd)rrrgrr4rhs rarzPoly.gcd\ Kxx{ 31 155% UU1XF'51 16{rdc|j|\}}}}t|jdr|j|}n t |d||S)a Returns polynomial LCM of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 1, x).lcm(Poly(x**2 - 3*x + 2, x)) Poly(x**3 - 2*x**2 - x + 2, x, domain='ZZ') lcm)rrrgrr4rhs rarzPoly.lcms rrdc|jjj|}t|jdr|jj |}n t |d|j |S)a Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 + 3*x**2 + 5*x + 7, x).trunc(3) Poly(-x**3 - x + 1, x, domain='ZZ') trunc)rgrrrrr4r)r\pr_s rarz Poly.trunc sV EEII  a  155' "UU[[^F'73 3uuV}rdc|}|r0|jjjr|j}t |jdr|jj }n t |d|j|S)az Divides all coefficients by ``LC(f)``. Examples ======== >>> from sympy import Poly, ZZ >>> from sympy.abc import x >>> Poly(3*x**2 + 6*x + 9, x, domain=ZZ).monic() Poly(x**2 + 2*x + 3, x, domain='QQ') >>> Poly(3*x**2 + 4*x + 2, x, domain=ZZ).monic() Poly(x**2 + 4/3*x + 2/3, x, domain='QQ') monic)rgrrrrrr4rrrr\r_s rarz Poly.monic s_"  AEEII%% A 155' "UU[[]F'73 3uuV}rdct|jdr|jj}n t|d|jjj |S)z Returns the GCD of polynomial coefficients. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(6*x**2 + 8*x + 12, x).content() 2 content)rrgrr4rrrs rarz Poly.content rrdct|jdr|jj\}}n t|d|jjj ||j |fS)a Returns the content and a primitive form of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 8*x + 12, x).primitive() (2, Poly(x**2 + 4*x + 6, x, domain='ZZ')) primitive)rrgrr4rrr)r\contr_s rarzPoly.primitive sY 155+ &55??,LD&';7 7uuyy!!$'v66rdc|j|\}}}}t|jdr|j|}n t |d||S)a Computes the functional composition of ``f`` and ``g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x, x).compose(Poly(x - 1, x)) Poly(x**2 - x, x, domain='ZZ') compose)rrrgrr4rhs rarz Poly.compose sKxx{ 31 155) $YYq\F'95 56{rdct|jdr|jj}n t|dt t |j |S)a= Computes a functional decomposition of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**4 + 2*x**3 - x - 1, x, domain='ZZ').decompose() [Poly(x**2 - x - 1, x, domain='ZZ'), Poly(x**2 + x, x, domain='ZZ')] decompose)rrgrr4rtrrrs rarzPoly.decompose sE 155+ &UU__&F';7 7Cv&''rdcV|j|jj|S)am Efficiently compute Taylor shift ``f(x + a)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).shift(2) Poly(x**2 + 2*x + 1, x, domain='ZZ') See Also ======== shift_list: Analogous method for multivariate polynomials. )rrgshiftr\rs rarz Poly.shift s$uuQUU[[^$$rdcV|j|jj|S)ah Efficiently compute Taylor shift ``f(X + A)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x*y, [x,y]).shift_list([1, 2]) == Poly((x+1)*(y+2), [x,y]) True See Also ======== shift: Analogous method for univariate polynomials. )rrg shift_listrs rar zPoly.shift_list( s"$uuQUU%%a())rdcB|j|\}}|j|\}}|j|\}}t|jdr1|jj|j|j}n t |d|j |S)a3 Efficiently evaluate the functional transformation ``q**n * f(p/q)``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).transform(Poly(x + 1, x), Poly(x - 1, x)) Poly(4, x, domain='ZZ') transform)rrrgr r4r)r\rrtPrrr_s rar zPoly.transform< s|wwqz1wwqz1wwqz1 155+ &UU__QUUAEE2F';7 7uuV}rdc"|}|r0|jjjr|j}t |jdr|jj }n t |dtt|j|S)a Computes the Sturm sequence of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 2*x**2 + x - 3, x).sturm() [Poly(x**3 - 2*x**2 + x - 3, x, domain='QQ'), Poly(3*x**2 - 4*x + 1, x, domain='QQ'), Poly(2/9*x + 25/9, x, domain='QQ'), Poly(-2079/4, x, domain='QQ')] sturm) rgrrrrrr4rtrrrs rarz Poly.sturmV sg"  AEEII%% A 155' "UU[[]F'73 3Cv&''rdct|jdr|jj}n t|d|Dcgc]\}}|j ||fc}}Scc}}w)aI Computes greatest factorial factorization of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**5 + 2*x**4 - x**3 - 2*x**2 >>> Poly(f).gff_list() [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] gff_list)rrgrr4r)r\r_r]rRs rarz Poly.gff_lists sS 155* %UU^^%F':6 6*01$!Qq1 111sA$ct|jdr|jj}n t|d|j |S)a Computes the product, ``Norm(f)``, of the conjugates of a polynomial ``f`` defined over a number field ``K``. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> a, b = sqrt(2), sqrt(3) A polynomial over a quadratic extension. Two conjugates x - a and x + a. >>> f = Poly(x - a, x, extension=a) >>> f.norm() Poly(x**2 - 2, x, domain='QQ') A polynomial over a quartic extension. Four conjugates x - a, x - a, x + a and x + a. >>> f = Poly(x - a, x, extension=(a, b)) >>> f.norm() Poly(x**4 - 4*x**2 + 4, x, domain='QQ') norm)rrgrr4r)r\rus rarz Poly.norm s;8 155& ! A'62 2uuQxrdct|jdr|jj\}}}n t|d||j ||j |fS)ah Computes square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import Poly, sqrt >>> from sympy.abc import x >>> s, f, r = Poly(x**2 + 1, x, extension=[sqrt(3)]).sqf_norm() >>> s [1] >>> f Poly(x**2 - 2*sqrt(3)*x + 4, x, domain='QQ') >>> r Poly(x**4 - 4*x**2 + 16, x, domain='QQ') sqf_norm)rrgrr4r)r\rr]rus rarz Poly.sqf_norm sR0 155* %eenn&GAq!':6 6!%%(AEE!H$$rdct|jdr|jj}n t|d|j |S)z Computes square-free part of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**3 - 3*x - 2, x).sqf_part() Poly(x**2 - x - 2, x, domain='ZZ') sqf_part)rrgrr4rrs rarz Poly.sqf_part rrdc&t|jdr|jj|\}}n t|d|jjj ||Dcgc]\}}|j ||fc}}fScc}}w)a  Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16 >>> Poly(f).sqf_list() (2, [(Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) >>> Poly(f).sqf_list(all=True) (2, [(Poly(1, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)]) sqf_list)rrgrr4rrr)r\allrfactorsr]rRs rarz Poly.sqf_list sq, 155* %UU^^C0NE7':6 6uuyy!!%(W*MTQAEE!Ha=*MMM*Ms+B ct|jdr|jj|}n t|d|Dcgc]\}}|j ||fc}}Scc}}w)a Returns a list of square-free factors of ``f``. Examples ======== >>> from sympy import Poly, expand >>> from sympy.abc import x >>> f = expand(2*(x + 1)**3*x**4) >>> f 2*x**7 + 6*x**6 + 6*x**5 + 2*x**4 >>> Poly(f).sqf_list_include() [(Poly(2, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] >>> Poly(f).sqf_list_include(all=True) [(Poly(2, x, domain='ZZ'), 1), (Poly(1, x, domain='ZZ'), 2), (Poly(x + 1, x, domain='ZZ'), 3), (Poly(x, x, domain='ZZ'), 4)] sqf_list_include)rrgrr4r)r\rrr]rRs rarzPoly.sqf_list_include sY4 155, -ee,,S1G'+=> >*12$!Qq1 222sA%ct|jdr |jj\}}n t|d|jjj||Dcgc]\}}|j||fc}}fS#t$r?|j dk(r|j gfcYSt j|dfgfcYSwxYwcc}}w)a~ Returns a list of irreducible factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y >>> Poly(f).factor_list() (2, [(Poly(x + y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)]) factor_listrr) rrgrr5rrZrrr4rrr)r\rrr]rRs rarzPoly.factor_list s" 155- ( +!"!2!2!4w(=9 9uuyy!!%(W*MTQAEE!Ha=*MMM +88:?99;?*55Aq6(?*  ++NsB +C .C=CCct|jdr |jj}n t |d|Dcgc]\}}|j ||fc}}S#t$r|dfgcYSwxYwcc}}w)a Returns a list of irreducible factors of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y >>> Poly(f).factor_list_include() [(Poly(2*x + 2*y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)] factor_list_includer)rrgr r5r4r)r\rr]rRs rar zPoly.factor_list_include= s{" 155/ 0 %%335(+@A A*12$!Qq1 22  Ax 3sA%A9%A65A6ch|%tj|}|dkr td|tj|}|tj|}t|jdr"|jj ||||||}n t |d|rLd}|stt||Sd} |\} } tt|| tt| | fSd}|stt||Sd} |\} } tt|| tt| | fS) a Compute isolating intervals for roots of ``f``. For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used. References ========== .. [#] Alkiviadis G. Akritas and Adam W. Strzebonski: A Comparative Study of Two Real Root Isolation Methods . Nonlinear Analysis: Modelling and Control, Vol. 10, No. 4, 297-304, 2005. .. [#] Alkiviadis G. Akritas, Adam W. Strzebonski and Panagiotis S. Vigklas: Improving the Performance of the Continued Fractions Method Using new Bounds of Positive Roots. Nonlinear Analysis: Modelling and Control, Vol. 13, No. 3, 265-279, 2008. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).intervals() [((-2, -1), 1), ((1, 2), 1)] >>> Poly(x**2 - 3, x).intervals(eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] r!'eps' must be a positive rational intervalsrepsinfsupfastsqfc`|\}}tj|tj|fSrr*r)intervalrrs ra_realzPoly.intervals.._real s&1 A A77rdc|\\}}\}}tj|ttj|zztj|ttj|zzfSrr*rr) rectangleuvrrs ra_complexz Poly.intervals.._complex sW!*AA A2;;q>)99 A2;;q>)99;;rdcj|\\}}}tj|tj|f|fSrr+)r,rrrRs rar-zPoly.intervals.._real s/$ AQQ8!<._complex sg&/# !Q!Q!Q!BKKN*::Q!BKKN*::<=>@@rd) r*rrrrgr#r4rtr) r\rr%r&r'r(r)r_r-r3 real_part complex_parts rar#zPoly.intervalsX s34 ?**S/Cax !DEE ?**S/C ?**S/C 155+ &UU__Scs3%HF(;7 7  8Cv.// ; '- #I|E9-.S<5P0QQ Q =Cv.// @ '- #I|E9-.S<5P0QQ Qrdc|r|js tdtj|tj|}}|%tj|}|dkr t d| t |}n|d}t |jdr$|jj|||||\}}n t|dtj|tj|fS)a Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3, x).refine_root(1, 2, eps=1e-2) (19/11, 26/15) z&only square-free polynomials supportedrr"r refine_root)r%stepsr() is_sqfr9r*rrr(rrgr9r4r) r\rrr%r:r( check_sqfrTs rar9zPoly.refine_root s QXX!"JK Kzz!}bjjm1 ?**S/Cax !DEE  JE [E 155- (55$$Qs%d$KDAq'=9 9{{1~r{{1~--rdcdd\}}|rt|}|tjurd}nR|j\}}|st j |}n't ttj ||fd}}|rt|}|tjurd}nR|j\}}|st j |}n't ttj ||fd}}|rL|rJt|jdr(|jj||}t|St|d|r||tjf}|r||tjf}t|jdr(|jj||}t|St|d)a< Return the number of roots of ``f`` in ``[inf, sup]`` interval. Examples ======== >>> from sympy import Poly, I >>> from sympy.abc import x >>> Poly(x**4 - 4, x).count_roots(-3, 3) 2 >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I) 1 TTNFcount_real_rootsr&r'count_complex_roots)r"rr as_real_imagr*rrtrInfinityrrgr@r4rrBr)r\r&r'inf_realsup_realreimcounts ra count_rootszPoly.count_roots s (( ?#,Ca((())+B**S/C$(RZZ"b)B$CUC ?#,Cajj ))+B**S/C$(RZZ"b)B$CUC quu01..3C.@u~,A/ABBCOBGGnCOBGGnquu3411cs1Cu~,A/DEErdcZtjjj|||S)a  Get an indexed root of a polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4) >>> f.root(0) -1/2 >>> f.root(1) 2 >>> f.root(2) 2 >>> f.root(3) Traceback (most recent call last): ... IndexError: root index out of [-3, 2] range, got 3 >>> Poly(x**5 + x + 1).root(0) CRootOf(x**3 - x**2 + 1, 0) radicals)sympypolys rootoftoolsrootof)r\rrMs rarootz Poly.roots&6{{&&--a-JJrdctjjjj ||}|r|St |dS)a Return a list of real roots with multiplicities. See :func:`real_roots` for more explanation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).real_roots() [CRootOf(x**3 + x + 1, 0)] rLFmultiple)rNrOrPCRootOf real_rootsrG)r\rUrMrealss rarWzPoly.real_roots%s>" ''//::1x:P L/ /rdctjjjj ||}|r|St |dS)a Return a list of real and complex roots with multiplicities. See :func:`all_roots` for more explanation. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots() [-1/2, 2, 2] >>> Poly(x**3 + x + 1).all_roots() [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)] rLFrT)rNrOrPrV all_rootsrG)r\rUrMrootss rarZzPoly.all_roots=s>( ''//99!h9O L/ /rdc  |jrtd|z|jdkrgS|jjt ur'|j Dcgc] }t|}}n|jjturY|j Dcgc]}|j}}t|}|j Dcgc]}t||z}}n[|j Dcgc]"}|j|j$}} |Dcgc]}tj|}}tj"j$}|tj"_ddlm  tj*|||d|jdz} t-t/t0t3| fd  } |tj"_| Scc}wcc}wcc}wcc}wcc}w#t$r#t!d|jjzwxYw#t4$ru tj*|||d|jd z} t-t/t0t3| fd  } n#t4$rt5d |d|wxYwYwxYw#|tj"_wxYw)a Compute numerical approximations of roots of ``f``. Parameters ========== n ... the number of digits to calculate maxsteps ... the maximum number of iterations to do If the accuracy `n` cannot be reached in `maxsteps`, it will raise an exception. You need to rerun with higher maxsteps. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 3).nroots(n=15) [-1.73205080756888, 1.73205080756888] >>> Poly(x**2 - 3).nroots(n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] z$Cannot compute numerical roots of %sr)r*z!Numerical domain expected, got %s)signF )maxstepscleanuperror extraprecc|jrdnd|jt|j|jfSNrrimagrealrcrur]s razPoly.nroots..s1!&&QaQVVVZ[\[a[aVb,crdkeyc|jrdnd|jt|j|jfSrdrerhs rarizPoly.nroots..s4aff!QVVSQRQWQW[Z^_`_e_eZf0grdz$convergence to root failed; try n < z or maxsteps > )is_multivariater:rrgrr+r1r(r*rtrrrCmpmathmpcrr5mpdps$sympy.functions.elementary.complexesr] polyrootsrtrr"sortedrM) r\r*r_r`rrdenomsfacrrr[r]s @ranrootsz Poly.nrootsXsm2  -6:< < 88:?I 5599?./lln=Uc%j=F= UUYY"_+,<<>:%egg:F:-C23,,.Ac%)nAFA"#1kkAk&3351F1 #:@A&**e,AA iimm = $$Vh#5AHHJrMKE Wu"cdfgE FIIM U>:A1B #!"E #"## #$ " "(((#5AHHJrMKS5&ghjk  "#x!"" " " FIIMstG#"G(G-;'G2%G<)G7G<:AH+7G<<,H(+ J)5AJJ)J##J)&J,(J))J,,Kc|jrtd|zi}|jdD].\}}|js|j \}}||| |z <0|S)a Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots() {0: 2, 1: 2} z!Cannot compute ground roots of %sr)rnr:r is_linearr1)r\r[factorrRrrs ra ground_rootszPoly.ground_rootssx  -3a79 9+ IFA((*1qbd   rdcR|jr tdt|}|jr|dk\r t |}nt d|z|j }td}|j|jj||z|z ||}|j||S)af Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - x**2 + 1) >>> f.nth_power_roots_poly(2) Poly(x**4 - 2*x**3 + 3*x**2 - 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(3) Poly(x**4 + 2*x**2 + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(4) Poly(x**4 + 2*x**3 + 3*x**2 + 2*x + 1, x, domain='ZZ') >>> f.nth_power_roots_poly(12) Poly(x**4 - 4*x**3 + 6*x**2 - 4*x + 1, x, domain='ZZ') zmust be a univariate polynomialrz&'n' must an integer and n >= 1, got %sr) rnr:r" is_Integerr(rrr rrrUr)r\r*rrrrus ranth_power_roots_polyzPoly.nth_power_roots_polys,  -13 3 AJ <yyArdc |jr td|jj}|jj j |}|dz }td|z di\}}}}t|}|dz|dzz fd} | || |} } | j| jz dz| j| jz dzz|kS)a Decide whether two roots of this polynomial are equal. Examples ======== >>> from sympy import Poly, cyclotomic_poly, exp, I, pi >>> f = Poly(cyclotomic_poly(5)) >>> r0 = exp(2*I*pi/5) >>> indices = [i for i, r in enumerate(f.all_roots()) if f.same_root(r, r0)] >>> print(indices) [3] Raises ====== DomainError If the domain of the polynomial is not :ref:`ZZ`, :ref:`QQ`, :ref:`RR`, or :ref:`CC`. MultivariatePolynomialError If the polynomial is not univariate. PolynomialError If the polynomial is of degree < 2. zMust be a univariate polynomial rc0tt|S)Nr)rr)rr)s rariz Poly.same_root..s~&?Q&GHrd) rnr:rgmignotte_sep_bound_squaredrP get_fieldrrrrgrf) r\rr dom_delta_sqdelta_sqeps_sqrurr*evABr)s @ra same_rootzPoly.same_roots4  -13 3uu779 88%%'00>A1V8Q+ 1a AJ !VA  H !ube1!#qvv&::VCCrdcf|j|\}}}}t|dr|j||}n t|d|sY|jr|j }|\}} } } |j |}|j | } || z || || fStt||S)a Cancel common factors in a rational function ``f/g``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x)) (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True) (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ')) cancel)include) rrrr4rrrr7r) r\r]rrrrrr_cpcqrrts rarz Poly.cancels"!S!Q 1h XXaX1F'84 4!!lln!LBAqb!Bb!Bb5#a&#a&( (S&)* *rdcr|jr|jttfvr t d|j r%|jtk(r|tj fS|j}|j\}}|jt|j|j|fS)aQ Turn any univariate polynomial over :ref:`QQ` or :ref:`ZZ` into a monic polynomial over :ref:`ZZ`, by scaling the roots as necessary. Explanation =========== This operation can be performed whether or not *f* is irreducible; when it is, this can be understood as determining an algebraic integer generating the same field as a root of *f*. Examples ======== >>> from sympy import Poly, S >>> from sympy.abc import x >>> f = Poly(x**2/2 + S(1)/4 * x + S(1)/8, x, domain='QQ') >>> f.make_monic_over_integers_by_scaling_roots() (Poly(x**2 + 2*x + 4, x, domain='ZZ'), 4) Returns ======= Pair ``(g, c)`` g is the polynomial c is the integer by which the roots had to be scaled z,Polynomial must be univariate over ZZ or QQ.) rrPr+r*ris_monicrrrr rTrr)r\fmrrs ra)make_monic_over_integers_by_scaling_rootsz.Poly.make_monic_over_integers_by_scaling_rootsCs<!((2r(":KL L ::!((b.bff9 B??$DAq<<RVV a088:A= =rdcddlm}m}m}m}|j r$|j r|jttfvr td||||d}t|j} |j} | | kDrtd| d| dkr td| dk(rdd lm} | j d } } n>| d k(rdd lm}|j$d } } n$|j'\}}|| |||\} } |r| n| j)}|| fS)a Compute the Galois group of this polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - 2) >>> G, _ = f.galois_group(by_name=True) >>> print(G) S4TransitiveSubgroups.D4 See Also ======== sympy.polys.numberfields.galoisgroups.galois_group r)_galois_group_degree_3_galois_group_degree_4_lookup(_galois_group_degree_5_lookup_ext_factor_galois_group_degree_6_lookupz>@DAq1a9 JID#D!4!4!6#v rdc.|jjS)a Returns ``True`` if ``f`` is a zero polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False )rgis_zerors rarz Poly.is_zeros"uu}}rdc.|jjS)a Returns ``True`` if ``f`` is a unit polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_one False >>> Poly(1, x).is_one True )rgis_oners rarz Poly.is_one"uu||rdc.|jjS)a  Returns ``True`` if ``f`` is a square-free polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 - 2*x + 1, x).is_sqf False >>> Poly(x**2 - 1, x).is_sqf True )rgr;rs rar;z Poly.is_sqfrrdc.|jjS)a  Returns ``True`` if the leading coefficient of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x + 2, x).is_monic True >>> Poly(2*x + 2, x).is_monic False )rgrrs rarz Poly.is_monics"uu~~rdc.|jjS)a; Returns ``True`` if GCD of the coefficients of ``f`` is one. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(2*x**2 + 6*x + 12, x).is_primitive False >>> Poly(x**2 + 3*x + 6, x).is_primitive True )rg is_primitivers rarzPoly.is_primitive"uu!!!rdc.|jjS)aJ Returns ``True`` if ``f`` is an element of the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x, x).is_ground False >>> Poly(2, x).is_ground True >>> Poly(y, x).is_ground True )rg is_groundrs rarzPoly.is_grounds&uurdc.|jjS)a, Returns ``True`` if ``f`` is linear in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x + y + 2, x, y).is_linear True >>> Poly(x*y + 2, x, y).is_linear False )rgrzrs rarzzPoly.is_linears"uurdc.|jjS)a6 Returns ``True`` if ``f`` is quadratic in all its variables. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x*y + 2, x, y).is_quadratic True >>> Poly(x*y**2 + 2, x, y).is_quadratic False )rg is_quadraticrs rarzPoly.is_quadratic'rrdc.|jjS)a% Returns ``True`` if ``f`` is zero or has only one term. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(3*x**2, x).is_monomial True >>> Poly(3*x**2 + 1, x).is_monomial False )rg is_monomialrs rarzPoly.is_monomial:s"uu   rdc.|jjS)aZ Returns ``True`` if ``f`` is a homogeneous polynomial. A homogeneous polynomial is a polynomial whose all monomials with non-zero coefficients have the same total degree. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then use :func:`Poly.homogeneous_order`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x*y, x, y).is_homogeneous True >>> Poly(x**3 + x*y, x, y).is_homogeneous False )rgis_homogeneousrs rarzPoly.is_homogeneousMs,uu###rdc.|jjS)aG Returns ``True`` if ``f`` has no factors over its domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + x + 1, x, modulus=2).is_irreducible True >>> Poly(x**2 + 1, x, modulus=2).is_irreducible False )rgrrs rarzPoly.is_irreduciblees"uu###rdc2t|jdk(S)a Returns ``True`` if ``f`` is a univariate polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x + 1, x).is_univariate True >>> Poly(x*y**2 + x*y + 1, x, y).is_univariate False >>> Poly(x*y**2 + x*y + 1, x).is_univariate True >>> Poly(x**2 + x + 1, x, y).is_univariate False rrrVrs rarzPoly.is_univariatex*166{ardc2t|jdk7S)a Returns ``True`` if ``f`` is a multivariate polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y >>> Poly(x**2 + x + 1, x).is_multivariate False >>> Poly(x*y**2 + x*y + 1, x, y).is_multivariate True >>> Poly(x*y**2 + x*y + 1, x).is_multivariate False >>> Poly(x**2 + x + 1, x, y).is_multivariate True rrrs rarnzPoly.is_multivariaterrdc.|jjS)a Returns ``True`` if ``f`` is a cyclotomic polnomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 >>> Poly(f).is_cyclotomic False >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 >>> Poly(g).is_cyclotomic True )rg is_cyclotomicrs rarzPoly.is_cyclotomics,uu"""rdc"|jSr)rcrs ra__abs__z Poly.__abs__ uuwrdc"|jSr)rers ra__neg__z Poly.__neg__rrdc$|j|Srrr\r]s ra__add__z Poly.__add__uuQxrdc$|j|Srrrs ra__radd__z Poly.__radd__rrdc$|j|Srrkrs ra__sub__z Poly.__sub__rrdc$|j|Srrrs ra__rsub__z Poly.__rsub__rrdc$|j|Srrrs ra__mul__z Poly.__mul__rrdc$|j|Srrrs ra__rmul__z Poly.__rmul__rrdr*cR|jr|dk\r|j|StS)Nr)r~rprX)r\r*s ra__pow__z Poly.__pow__s" <_15588AEEZ^8C__rdNNr)FF)FTr)rFNT)FNNNFFNNFFr?rl2T)FF)r[ __module__ __qualname____doc__ __slots__is_commutativerv _op_priorityr} classmethodrpropertyrr{rrrrrUrrrsrwrxrorrrrrPrrrrrrrrrrrrjrrrrrrrr r%r'rrrr1r3r5r8r:r r?rZrErGrIrLrQrUrWr[r]r_rarcrerrkrrnrprsrwryr{r~rrrr rrrrrrrrrrrrrrrrrrrrr_eval_derivativerrrrrrrrrrrrrrrrrrrrrr r rrrrrrrrr r#r9rJrRrWrZrxr|rrrrrrrr;rrrrzrrrrrrnrrrrcrrrrrrr rXrrrrrrrrrrrrrrr __classcell__rs@rarTrTis3j INGL0>  EE(('(( (( (( (( AA&AA*,(( AA"55<: !!,OONNOO83j+:0 )"J* *%&!MF2N4"LH D***40 J,)(Q(C "(J #=J 2&)$=L4* *#$J(%T ****04*0>>>04.%N8>%N#J#J(T@(5<:&;* &B> D&2#%J'*I#VI V*:...:**7*.(*%(*(4(:2.!F%>*N:3BN<36JRX#.J=~K:0006N`6&P1Df#+J%>N4l$$$$""$($""$!!$$$.$$$  ,  ,##.^$"%" ^$'%'^$'%'()"^$%, *`rdrTcbeZdZdZdZfdZedZede dZ dZ dZ xZ S) PurePolyz)Class for representing pure polynomials. c|jfS)z$Allow SymPy to hash Poly instances. )rgrs rarzPurePoly._hashable_content-s{rdc t|Srrrs rarzPurePoly.__hash__1rrdc|jS)aR Free symbols of a polynomial. Examples ======== >>> from sympy import PurePoly >>> from sympy.abc import x, y >>> PurePoly(x**2 + 1).free_symbols set() >>> PurePoly(x**2 + y).free_symbols set() >>> PurePoly(x**2 + y, x).free_symbols {y} )rrs rarzPurePoly.free_symbols4s&***rdrc||}}|js- |j||j|j}t|jt|jk7ry|jj|jjk7rg |jjj|jj|j}|j|}|j|}|j|jk(S#tt t f$rYywxYw#t$rYywxYwr) rvrrVrr9r5r6rrgrrr7r)rrr\r]rs rarzPurePoly.__eq__IsU1yy KK166!,,.KA qvv;#aff+ % 5599 ! eeiiooaeeii8 S!A S!Auu~$[.A  %  s$,DAD1D.-D.1 D=<D=ct||jxr'|jj|jdSr)rSrrgrrs rarzPurePoly._strict_eqas-!Q[[)JaeehhquuTh.JJrdctt|}|jsk |jj|j|j|jj |jjj |fSt|jt|jk7rtd|d|t|jtrt|jtstd|d||j|j}|jjj|jj|}|jj|}|jj|}||dffd }||||fS#t $rtd|d|wxYw)Nrrcp|!|d|||dzdz}|s|j|Sj|g|Srrrs rarzPurePoly._unify..per{rrd)r"rvrgrrrr6r7rrVrSr1rrr)r\r]rVrrrrrzs @rarzPurePoly._unifydsB AJyy Luuyy!%% !%%)):N:Nq:Q0RRR qvv;#aff+ %#A$FG G155#&:aeeS+A#A$FG Gkkvveeiiooaeeii. EEMM#  EEMM# 4 'CA~5" L'Q(JKK Ls A)FF7)r[rrrrrrrr rXrrrrrs@rarr)sJ3"++(().K rdrcFtj||}t||Sr)rlrm_poly_from_expr)rrVr{r|s rapoly_from_exprr's#   d +C 4 %%rdc|t|}}t|ts t||||jrU|j j ||}|j|_|j|_|jd|_ ||fS|jr|j}t||\}}|js t|||ttt|j\}}|j}|t||\|_}ntt!|j"|}t%tt||}t&j)||}|jd|_ ||fS)rTrF)r"rSr r<rvrrwrVrPrOexpandrCrtrrr(rrrqrTrr)rr|origrDrgrrrPs rar&r&sEwt}$D dE " dD11 ~~((s399[[ 99 CISy {{}tS)HC 88 dD11#tCIIK012NFF ZZF ~-f#> Fc&++V45 tC'( )C ??3 $D yy 9rdcFtj||}t||S)(Construct polynomials from expressions. )rlrm_parallel_poly_from_expr)exprsrVr{r|s raparallel_poly_from_exprr/s#   d +C #E3 //rdc jt|dk(r|\}}t|trt|tr|jj ||}|jj ||}|j |\}}|j |_|j|_|jd|_||g|fSt|g}}gg}}d}t|D]\}} t| } t| trL| jr|j|n0|j||jr| j} nd}|j| |rt!|||d|r|D]}||j#||<t%||\} }|j st!|||dddlm} |j D]} t| | st+dgg}} g}g}| D]i}tt-t|j/\}}| j1||j||jt|k|j}|t3| |\|_} ntt5|j6| } |D]} |j| d| | | d} g}t-||D]J\}}t9tt-||}tj;||}|j|L|jt=||_||fS) r,rNTFr Piecewisez&Piecewise generators do not make senser)rrSrTrrwrrVrPrOrtrr"r rvappendr)r<rZrD$sympy.functions.elementary.piecewiser2r9rrextendr(rrrqrrbool)r.r|r\r]origs_exprs_polysfailedrrrepsr2rR coeffs_listlengthsr3r1rgrrrPrOrDs rar-r-s 5zQ1 a :a#6 &&q#.A &&q#.A771:DAqvvCHCJyy   q63; ;5EFF FU#4t} dE "|| a  a ::;;=DF T  eUD99  *AQx'')E!H *)4ID# 88 eUD99> XXL a #!"JK KLrKJJ$c4 #4566"&!s6{# $ZZF ~"2;C"H K3v00+>? &+bq/*!!"o & Ej*54FF+,-sC( T  yyL #:rdc.t|}||vr|||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )rq)r{rkrBs ra _update_argsr?s :D $S Krdc  t|d}t|dj}|jr|}|jj}n.|j}|s |rt |\}}nt ||\}}|r"|rt j St jS|sT|jr*|jvrt |j\}}|jvrnt j S|jsRt|jdkDr:ttd|dtt|jd|dj|}t!|t"r t%|St jS)a Return the degree of ``f`` in the given variable. The degree of 0 is negative infinity. Examples ======== >>> from sympy import degree >>> from sympy.abc import x, y >>> degree(x**2 + y*x + 1, gen=x) 2 >>> degree(x**2 + y*x + 1, gen=y) 1 >>> degree(0, x) -oo See also ======== sympy.polys.polytools.Poly.total_degree degree_list Trrzj A symbolic generator of interest is required for a multivariate expression like func = z, e.g. degree(func, gen = z)) instead of degree(func, gen = z ). )r" is_NumberrvrZr'rZerorrVrrrrInextrrrSr(r)r\r gen_is_NumrisNumrr_s rarr%s86 $AT*44Jyy  %% %a(1%a-1 qvv2 2 22  99AFF*!!))+.DAq aff 66M YY3q~~.2 $wq~~./ $678 8 XXc]F(576?M1;M;MMrdct|}|jr|j}|jr d}t|S|jr|xs |j}t ||j }t|S)a Return the total_degree of ``f`` in the given variables. Examples ======== >>> from sympy import total_degree, Poly >>> from sympy.abc import x, y >>> total_degree(1) 0 >>> total_degree(x + x*y) 2 >>> total_degree(x + x*y, x) 1 If the expression is a Poly and no variables are given then the generators of the Poly will be used: >>> p = Poly(x + x*y, y) >>> total_degree(p) 1 To deal with the underlying expression of the Poly, convert it to an Expr: >>> total_degree(p.as_expr()) 2 This is done automatically if any variables are given: >>> total_degree(p, x) 1 See also ======== degree r)r"rvrZrArVrTrr)r\rVrrvs rarr`slP  Ayy IIK{{  2; 99>166D !T] ' ' ) 2;rdctj|dg t|g|i|\}}|j }t tt|S#t$r}t dd|d}~wwxYw)z Return a list of degrees of ``f`` in all variables. Examples ======== >>> from sympy import degree_list >>> from sympy.abc import x, y >>> degree_list(x**2 + y*x + 1) (2, 1) rOrrN) rl allowed_flagsr'r<r=rr7rr)r\rVr{rr|r|degreess rarrss $ *71D1D13mmoG Wg& '' 7 q#667sA A/ A**A/ctj|dg t|g|i|\}}|j |j S#t$r}t dd|d}~wwxYw)z Return the leading coefficient of ``f``. Examples ======== >>> from sympy import LC >>> from sympy.abc import x, y >>> LC(4*x**2 + 2*x*y**2 + x*y + 3*y) 4 rOrrNr,)rlrIr'r<r=rrir\rVr{rr|r|s rarrsk $ *.1D1D13 44cii4   .a--.sA A" AA"ctj|dg t|g|i|\}}|j |j }|jS#t$r}t dd|d}~wwxYw)z Return the leading monomial of ``f``. Examples ======== >>> from sympy import LM >>> from sympy.abc import x, y >>> LM(4*x**2 + 2*x*y**2 + x*y + 3*y) x**2 rOrrNr,)rlrIr'r<r=rrirZ)r\rVr{rr|r|rs rarrsv $ *.1D1D13 DDsyyD !E ==? .a--.sA A2 A--A2ctj|dg t|g|i|\}}|j |j \}}||jzS#t$r}t dd|d}~wwxYw)z Return the leading term of ``f``. Examples ======== >>> from sympy import LT >>> from sympy.abc import x, y >>> LT(4*x**2 + 2*x*y**2 + x*y + 3*y) 4*x**2 rOrrNr,)rlrIr'r<r=rrirZ)r\rVr{rr|r|rrs rarrs $ *.1D1D1344cii4(LE5   .a--.sA A8& A33A8c$tj|dg t||fg|i|\\}}}|j |\}} |j s |j| jfS|| fS#t$r}t dd|d}~wwxYw)z Compute polynomial pseudo-division of ``f`` and ``g``. Examples ======== >>> from sympy import pdiv >>> from sympy.abc import x >>> pdiv(x**2 + 1, 2*x - 4) (2*x + 4, 20) rOrsrN)rlrIr/r<r=rsrOrZ r\r]rVr{rrr|r|rtrus rarsrss $ *0-q!fDtDtD A 66!9DAq 99yy{AIIK''!t  03//0sA44 B= B  Bctj|dg t||fg|i|\\}}}|j |}|j s|jS|S#t$r}t dd|d}~wwxYw)z Compute polynomial pseudo-remainder of ``f`` and ``g``. Examples ======== >>> from sympy import prem >>> from sympy.abc import x >>> prem(x**2 + 1, 2*x - 4) 20 rOrwrN)rlrIr/r<r=rwrOrZ r\r]rVr{rrr|r|rus rarwrws $ *0-q!fDtDtD A q A 99yy{ 03//0A A:( A55A:c.tj|dg t||fg|i|\\}}} |j |}|js|jS|S#t$r}t dd|d}~wwxYw#t $r t ||wxYw)z Compute polynomial pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pquo >>> from sympy.abc import x >>> pquo(x**2 + 1, 2*x - 4) 2*x + 4 >>> pquo(x**2 - 1, 2*x - 1) 2*x + 1 rOryrN) rlrIr/r<r=ryr;rOrZ r\r]rVr{rrr|r|rts raryry9s" $ *0-q!fDtDtD A( FF1I 99yy{ 03//0 (!!Q''(s"A A> A;) A66A;>Bctj|dg t||fg|i|\\}}}|j |}|j s|jS|S#t$r}t dd|d}~wwxYw)a_ Compute polynomial exact pseudo-quotient of ``f`` and ``g``. Examples ======== >>> from sympy import pexquo >>> from sympy.abc import x >>> pexquo(x**2 - 1, 2*x - 2) 2*x + 2 >>> pexquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 rOr{rN)rlrIr/r<r=r{rOrZrUs rar{r{\s( $ *2-q!fDtDtD A  A 99yy{ 2!S112rSc>tj|ddg t||fg|i|\\}}}|j ||j \}} |js |j| jfS|| fS#t$r}t dd|d}~wwxYw)a Compute polynomial division of ``f`` and ``g``. Examples ======== >>> from sympy import div, ZZ, QQ >>> from sympy.abc import x >>> div(x**2 + 1, 2*x - 4, domain=ZZ) (0, x**2 + 1) >>> div(x**2 + 1, 2*x - 4, domain=QQ) (x/2 + 1, 5) rrOr~rNr) rlrIr/r<r=r~rrOrZrPs rar~r~s" $ 12/-q!fDtDtD A 555 "DAq 99yy{AIIK''!t  /q#../sB B BBctj|ddg t||fg|i|\\}}}|j ||j }|js|jS|S#t$r}t dd|d}~wwxYw)a Compute polynomial remainder of ``f`` and ``g``. Examples ======== >>> from sympy import rem, ZZ, QQ >>> from sympy.abc import x >>> rem(x**2 + 1, 2*x - 4, domain=ZZ) x**2 + 1 >>> rem(x**2 + 1, 2*x - 4, domain=QQ) 5 rrOrrNrX) rlrIr/r<r=rrrOrZrRs rarr" $ 12/-q!fDtDtD A achhA 99yy{ /q#../A,, B5 BBctj|ddg t||fg|i|\\}}}|j ||j }|js|jS|S#t$r}t dd|d}~wwxYw)z Compute polynomial quotient of ``f`` and ``g``. Examples ======== >>> from sympy import quo >>> from sympy.abc import x >>> quo(x**2 + 1, 2*x - 4) x/2 + 1 >>> quo(x**2 - 1, x - 1) x + 1 rrOrrNrX) rlrIr/r<r=rrrOrZrUs rarrrZr[ctj|ddg t||fg|i|\\}}}|j ||j }|js|jS|S#t$r}t dd|d}~wwxYw)aQ Compute polynomial exact quotient of ``f`` and ``g``. Examples ======== >>> from sympy import exquo >>> from sympy.abc import x >>> exquo(x**2 - 1, x - 1) x + 1 >>> exquo(x**2 + 1, 2*x - 4) Traceback (most recent call last): ... ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1 rrOrrNrX) rlrIr/r<r=rrrOrZrUs rarrs( $ 121-q!fDtDtD A !A 99yy{ 1C001r[ctj|ddg t||fg|i|\\}}}|j ||j\} } |js | j| jfS| | fS#t$rw}t |j \}\} } |j | | \} } |j| |j| fcYd}~S#t$rtdd|wxYwd}~wwxYw)aT Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import half_gcdex >>> from sympy.abc import x >>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x + 1) rrONrrrX) rlrIr/r<r(r.rrrnr=rrOrZ) r\r]rVr{rrr|r|rPrrrrs rarrs" $ 12 :-q!fDtDtD A <<< )DAq 99yy{AIIK''!t  :)#))4A :$$Q*DAq??1%vq'99 9# :#L!S9 9 : :s5B D C<&C";!C<D"C99C<<DcLtj|ddg t||fg|i|\\}}}|j ||j\} } } |js/| j| j| jfS| | | fS#t$r}t |j \}\} } |j | | \} } } |j| |j| |j| fcYd}~S#t$rtdd|wxYwd}~wwxYw)aZ Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import gcdex >>> from sympy.abc import x >>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x**2/5 - 6*x/5 + 2, x + 1) rrONrrrX) rlrIr/r<r(r.rrrnr=rrOrZ)r\r]rVr{rrr|r|rPrrrrrs rarr)s" $ 12 N-q!fDtDtD Aggachhg'GAq! 99yy{AIIK44!Qw N)#))4A Nll1a(GAq!??1%vq'96??1;MM M# 5#GQ4 4 5 Ns5B D#D7D 1D>D#DDD#ctj|ddg t||fg|i|\\}}}|j||j} |js| jS| S#t$ra}t |j \}\} } |j |j| | cYd}~S#t$rtdd|wxYwd}~wwxYw)a/ Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S, mod_inverse >>> from sympy.abc import x >>> invert(x**2 - 1, 2*x - 1) -4/3 >>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor For more efficient inversion of Rationals, use the :obj:`sympy.core.intfunc.mod_inverse` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.intfunc.mod_inverse rrONrrrX) rlrIr/r<r(r.rrrnr=rrOrZ) r\r]rVr{rrr|r|rPrrrs rarrPs@ $ 126-q!fDtDtD A "A 99yy{ 6)#))4A 6??6==A#67 7" 6#Ha5 5 6 6s/A,, C5C B71C7CCCc tj|dg t||fg|i|\\}}}|j |}|j s|D cgc]} | jc} S|S#t$r}t dd|d}~wwxYwcc} w)z Compute subresultant PRS of ``f`` and ``g``. Examples ======== >>> from sympy import subresultants >>> from sympy.abc import x >>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2] rOrrN)rlrIr/r<r=rrOrZ) r\r]rVr{rrr|r|r_rus rarrs $ *9-q!fDtDtD A__Q F 99%+, ,,  9C889 -sA-B - B6 BBFrctj|dg t||fg|i|\\}}}|r|j ||\} } n|j |} |j s@|r.| j D cgc]} | jc} fS| jS|r|  fS| S#t$r}t dd|d}~wwxYwcc} w)z Compute resultant of ``f`` and ``g``. Examples ======== >>> from sympy import resultant >>> from sympy.abc import x >>> resultant(x**2 + 1, x**2 - 1) 4 rOrrNr)rlrIr/r<r=rrOrZ) r\r]rrVr{rrr|r|r_rrus rarrs $ *5-q!fDtDtD AKKjK9 Q 99 >>#1%=aaiik%== =~~ 19   5 Q445&>sB.;C . C 7 CC ctj|dg t|g|i|\}}|j }|j s|jS|S#t$r}t dd|d}~wwxYw)z Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 rOrrN)rlrIr'r<r=rrOrZr\rVr{rr|r|r_s rarrs{ $ *81D1D13^^ F 99~~  83778A A4" A//A4c2tj|dg t||fg|i|\\}}}|j |\} } } |js/| j| j| jfS| | | fS#t$r}t |j \}\} } |j | | \} } } |j| |j| |j| fcYd}~S#t$rtdd|wxYwd}~wwxYw)a Compute GCD and cofactors of ``f`` and ``g``. Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors of ``f`` and ``g``. Examples ======== >>> from sympy import cofactors >>> from sympy.abc import x >>> cofactors(x**2 - 1, x**2 - 3*x + 2) (x - 1, x + 1, x - 2) rONrr) rlrIr/r<r(r.rrrnr=rOrZ)r\r]rVr{rrr|r|rPrrrrrs rarrs& $ * R-q!fDtDtD A++a.KAsC 99yy{CKKM3;;=88#s{ R)#))4A R **1a0KAsC??1%vs';V__S=QQ Q# 9#KC8 8 9 Rs5B DD*C71D1D7DDDc0t|}fd}||}||Stjdg t|gi\}}t |dkDrt d|Drn|d}|ddDcgc]}||z j } }t d| Dr4d} | D]} t| | jd} !t|| z S|s)|jstjSt!d| S|d|dd}}|D]!} |j#| }|j$s!n|js|j'S|Scc}w#t$r6} || j}||cYd} ~ Std t || d} ~ wwxYw) z Compute GCD of a list of polynomials. Examples ======== >>> from sympy import gcd_list >>> from sympy.abc import x >>> gcd_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x - 1 csqsot|\}}|s |jS|jrG|d|dd}}|D]'}|j||}|j |s'n|j |SyNrr)r(rrOrrrseqrPnumbersr_numberr{rVs ratry_non_polynomial_gcdz(gcd_list..try_non_polynomial_gcdsD.s3OFG{{"$$")!*gabk%F#ZZ7F}}V,  v..rdNrOrc3PK|]}|jxr |j ywr is_algebraic is_irrational.0rs ra zgcd_list..=$V3 0 0 FS5F5F FV$&rc34K|]}|jywr is_rationalrtfrcs raruzgcd_list..@2s3??2rgcd_listr)r"rlrIr/rrratsimpras_numer_denomrcr<r.r=rOrrBrTrrrZ)rkrVr{rnr_rOr|rrlstlcr|r|rDs `` rarrs #,C&$C (F   $ *?,S@4@4@ s s8a > ?s6>E6EAEE FF4F:FFct|dr||f|z}t|g|i|S| tdtj|dg t ||fg|i|\\}}}t t||f\}}|jrb|jrV|jrJ|jr>||z j} | jrt|| jdz S|j%|} |j*s| j-S| S#t$ra} t| j \} \}} | j#| j%||cYd} ~ S#t&$rt)dd| wxYwd} ~ wwxYw)z Compute GCD of ``f`` and ``g``. Examples ======== >>> from sympy import gcd >>> from sympy.abc import x >>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1 __iter__Nz2gcd() takes 2 arguments or a sequence of argumentsrOrrr)rrrrlrIr/rr"rqrrrrzrcrr<r(r.rrrnr=rOrZ r\r]rVr{rrr|rrr|r|rPr_s rarrcsjq* =4$;D)D)D)) LMM $ *3-q!fDtDtD A7QF#1 >>aoo!..Q__Q3--/C1S//1!4455UU1XF 99~~  3)#))4A 3??6::a#34 4" 3#E1c2 2 3 3s1 BD E<E77 EE<E44E77E<ct|}dttffd }||}||Stjdg t |gi\}}t |dkDrwtd|Dre|d}|ddDcgc]}||z j} }td| Dr+d} | D]} t| | jd} !|| zS|s)|jstj St#d| S|d |dd}}|D]} |j| }|js|j%S|Scc}w#t$r6} || j}||cYd} ~ Std t || d} ~ wwxYw) z Compute LCM of a list of polynomials. Examples ======== >>> from sympy import lcm_list >>> from sympy.abc import x >>> lcm_list([x**3 - 1, x**2 - 1, x**2 - 3*x + 2]) x**5 - x**4 - 2*x**3 - x**2 + x + 2 returncsmskt|\}}|s|j|jS|jr4|d|dd}}|D]}|j ||}|j|Syri)r(rrrOrrjs ratry_non_polynomial_lcmz(lcm_list..try_non_polynomial_lcms{D.s3OFGvzz22$$")!*gabk%8F#ZZ7F8v..rdNrOrc3PK|]}|jxr |j ywrrprss raruzlcm_list..rvrwrc34K|]}|jywrryr{s raruzlcm_list..r}r~lcm_listrr)r"rr rlrIr/rrrrrr<r.r=rOrrrTrZ)rkrVr{rr_rOr|rrrrr|r|rDs `` rarrs #,Cx~ $C (F   $ *?,S@4@4@ s s8a > ?s6>E E>E E F F+F 1FF ct|dr||f|z}t|g|i|S| tdtj|dg t ||fg|i|\\}}}t t||f\}}|jrY|jrM|jrA|jr5||z j} | jr|| jdzS|j#|} |j(s| j+S| S#t$ra} t| j\} \}} | j!| j#||cYd} ~ S#t$$rt'dd| wxYwd} ~ wwxYw)z Compute LCM of ``f`` and ``g``. Examples ======== >>> from sympy import lcm >>> from sympy.abc import x >>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2 rNz2lcm() takes 2 arguments or a sequence of argumentsrOrrr)rrrrlrIr/rr"rqrrrrzrr<r(r.rrrnr=rOrZrs rarrseq* =4$;D)D)D)) LMM $ *3-q!fDtDtD A7QF#1 >>aoo!..Q__Q3--/C++-a000UU1XF 99~~  3)#))4A 3??6::a#34 4" 3#E1c2 2 3 3s1 BD E3E.. EE3E++E..E3c 6t|}t|tr(tfd|j|jfDSt|t rt d|t|tr |jr|SjddrY|j|jDcgc]}t|gic}}jddd<t|giSjdd}tjdg t!|gi\}}|j\} }|j&j(rZ|j&j*r|j-d \} }|j/\} }|j&j*r|  z} nt0j2} t5t7|j8| D cgc] \} }| |z c}} }t;| d rt0j2} |d k(r|S|rt=| ||j?zSt=| |j?d jA\} }t=| ||zd Scc}w#t"$r} | j$cYd } ~ Sd } ~ wwxYwcc}} w) az Remove GCD of terms from ``f``. If the ``deep`` flag is True, then the arguments of ``f`` will have terms_gcd applied to them. If a fraction is factored out of ``f`` and ``f`` is an Add, then an unevaluated Mul will be returned so that automatic simplification does not redistribute it. The hint ``clear``, when set to False, can be used to prevent such factoring when all coefficients are not fractions. Examples ======== >>> from sympy import terms_gcd, cos >>> from sympy.abc import x, y >>> terms_gcd(x**6*y**2 + x**3*y, x, y) x**3*y*(x**3*y + 1) The default action of polys routines is to expand the expression given to them. terms_gcd follows this behavior: >>> terms_gcd((3+3*x)*(x+x*y)) 3*x*(x*y + x + y + 1) If this is not desired then the hint ``expand`` can be set to False. In this case the expression will be treated as though it were comprised of one or more terms: >>> terms_gcd((3+3*x)*(x+x*y), expand=False) (3*x + 3)*(x*y + x) In order to traverse factors of a Mul or the arguments of other functions, the ``deep`` hint can be used: >>> terms_gcd((3 + 3*x)*(x + x*y), expand=False, deep=True) 3*x*(x + 1)*(y + 1) >>> terms_gcd(cos(x + x*y), deep=True) cos(x*(y + 1)) Rationals are factored out by default: >>> terms_gcd(x + y/2) (2*x + y)/2 Only the y-term had a coefficient that was a fraction; if one does not want to factor out the 1/2 in cases like this, the flag ``clear`` can be set to False: >>> terms_gcd(x + y/2, clear=False) x + y/2 >>> terms_gcd(x*y/2 + y**2, clear=False) y*(x/2 + y) The ``clear`` flag is ignored if all coefficients are fractions: >>> terms_gcd(x/3 + y/2, clear=False) (2*x + 3*y)/6 See Also ======== sympy.core.exprtools.gcd_terms, sympy.core.exprtools.factor_terms c3<K|]}t|giywr)rU)rtrr{rVs raruzterms_gcd..^s N!)A555Nsz3Inequalities cannot be used with terms_gcd. Found: deepFr)clearTrONrr)r)!r"rSrlhsrhsrrr is_Atomrr`r{rUpoprlrIr'r<rrPrrrrrrrrrVrrrZ as_coeff_Mul)r\rVr{r*rrrrr|r|rdenomrrrterms `` rarUrUs3F 1:D!XNquu~NOO Az "RSUVV a !))  xxaffAFFCqy2T2T2CD X,t,t,, HHWd #E $ *1D1D13 ;;=DAq zz ::  ~~d~3HE1;;=q ::   UNE #affa.1$!QA1 2DE1 19K 5$qyy{"2335!))+U;HHJHE1 ud1fE 22KD xx 2s*.I.I3J 3 J< J J Jctj|ddg t|g|i|\}}|j t |}|js|jS|S#t$r}t dd|d}~wwxYw)z Reduce ``f`` modulo a constant ``p``. Examples ======== >>> from sympy import trunc >>> from sympy.abc import x >>> trunc(2*x**3 + 3*x**2 + 5*x + 7, 3) -x**3 - x + 1 rrOrrN) rlrIr'r<r=rr"rOrZ)r\rrVr{rr|r|r_s rarrs $ 1211D1D13WWWQZ F 99~~  1C001sA$$ A?- A::A?ctj|ddg t|g|i|\}}|j |j }|js|jS|S#t$r}t dd|d}~wwxYw)z Divide all coefficients of ``f`` by ``LC(f)``. Examples ======== >>> from sympy import monic >>> from sympy.abc import x >>> monic(3*x**2 + 4*x + 2) x**2 + 4*x/3 + 2/3 rrOrrNrX) rlrIr'r<r=rrrOrZrds rarrs $ 1211D1D13WW#((W #F 99~~  1C001sA&& B/ A<<Bctj|dg t|g|i|\}}|j S#t$r}t dd|d}~wwxYw)z Compute GCD of coefficients of ``f``. Examples ======== >>> from sympy import content >>> from sympy.abc import x >>> content(6*x**2 + 8*x + 12) 2 rOrrN)rlrIr'r<r=rrLs rarrsb $ *31D1D13 99; 3 1c223s; A AActj|dg t|g|i|\}}|j \}}|j s||jfS||fS#t$r}t dd|d}~wwxYw)a Compute content and the primitive form of ``f``. Examples ======== >>> from sympy.polys.polytools import primitive >>> from sympy.abc import x >>> primitive(6*x**2 + 8*x + 12) (2, 3*x**2 + 4*x + 6) >>> eq = (2 + 2*x)*x + 2 Expansion is performed by default: >>> primitive(eq) (2, x**2 + x + 1) Set ``expand`` to False to shut this off. Note that the extraction will not be recursive; use the as_content_primitive method for recursive, non-destructive Rational extraction. >>> primitive(eq, expand=False) (1, x*(2*x + 2) + 2) >>> eq.as_content_primitive() (2, x*(x + 1) + 1) rOrrN)rlrIr'r<r=rrOrZ)r\rVr{rr|r|rr_s rarrs@ $ *51D1D13;;=LD& 99V^^%%%V| 5 Q445sA A;) A66A;ctj|dg t||fg|i|\\}}}|j |}|j s|jS|S#t$r}t dd|d}~wwxYw)z Compute functional composition ``f(g)``. Examples ======== >>> from sympy import compose >>> from sympy.abc import x >>> compose(x**2 + x, x - 1) x**2 - x rOrrN)rlrIr/r<r=rrOrZ) r\r]rVr{rrr|r|r_s rarrs $ *3-q!fDtDtD AYYq\F 99~~  3 1c223rSctj|dg t|g|i|\}}|j }|j s|Dcgc]}|jc}S|S#t$r}t dd|d}~wwxYwcc}w)z Compute functional decomposition of ``f``. Examples ======== >>> from sympy import decompose >>> from sympy.abc import x >>> decompose(x**4 + 2*x**3 - x - 1) [x**2 - x - 1, x**2 + x] rOrrN)rlrIr'r<r=rrOrZr\rVr{rr|r|r_rus rarr/s $ *51D1D13[[]F 99%+, ,,  5 Q445 -sA' B' B0 A==Bc.tj|ddg t|g|i|\}}|j |j }|js|Dcgc]}|jc}S|S#t$r}t dd|d}~wwxYwcc}w)z Compute Sturm sequence of ``f``. Examples ======== >>> from sympy import sturm >>> from sympy.abc import x >>> sturm(x**3 - 2*x**2 + x - 3) [x**3 - 2*x**2 + x - 3, 3*x**2 - 4*x + 1, 2*x/9 + 25/9, -2079/4] rrOrrNrX) rlrIr'r<r=rrrOrZrs rarrMs $ 1211D1D13WW#((W #F 99%+, ,,  1C001 -sA4B4 B= B  Bc$tj|dg t|g|i|\}}|j }|j s%|Dcgc]\}}|j|fc}}S|S#t$r}t dd|d}~wwxYwcc}}w)a& Compute a list of greatest factorial factors of ``f``. Note that the input to ff() and rf() should be Poly instances to use the definitions here. Examples ======== >>> from sympy import gff_list, ff, Poly >>> from sympy.abc import x >>> f = Poly(x**5 + 2*x**4 - x**3 - 2*x**2, x) >>> gff_list(f) [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)] >>> (ff(Poly(x), 1)*ff(Poly(x + 2), 4)) == f True >>> f = Poly(x**12 + 6*x**11 - 11*x**10 - 56*x**9 + 220*x**8 + 208*x**7 - 1401*x**6 + 1090*x**5 + 2715*x**4 - 6720*x**3 - 1092*x**2 + 5040*x, x) >>> gff_list(f) [(Poly(x**3 + 7, x, domain='ZZ'), 2), (Poly(x**2 + 5*x, x, domain='ZZ'), 3)] >>> ff(Poly(x**3 + 7, x), 2)*ff(Poly(x**2 + 5*x, x), 3) == f True rOrrN)rlrIr'r<r=rrOrZ) r\rVr{rr|r|rr]rRs rarrks@ $ *41D1D13jjlG 99-45TQa 55 4 As334 6sA. B . B 7 BB ctd)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialrr\rVr{s ragffrs : ;;rdcXtj|dg t|g|i|\}}|j \}}}|D cgc] } t | } } |js!| |j|jfS| ||fS#t$r}t dd|d}~wwxYwcc} w)a Compute square-free norm of ``f``. Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``, where ``a`` is the algebraic extension of the ground domain. Examples ======== >>> from sympy import sqf_norm, sqrt >>> from sympy.abc import x >>> sqf_norm(x**2 + 1, extension=[sqrt(3)]) ([1], x**2 - 2*sqrt(3)*x + 4, x**4 - 4*x**2 + 16) rOrrN) rlrIr'r<r=rrrOrZ) r\rVr{rr|r|rr]rusis_exprs rarrs& $ *41D1D13jjlGAq!$% &bgbk &F & 99qyy{AIIK//q!| 4 As334 'sB B' B$ BB$ctj|dg t|g|i|\}}|j }|j s|jS|S#t$r}t dd|d}~wwxYw)z Compute square-free part of ``f``. Examples ======== >>> from sympy import sqf_part >>> from sympy.abc import x >>> sqf_part(x**3 - 3*x - 2) x**2 - x - 2 rOrrN)rlrIr'r<r=rrOrZrds rarrsz $ *41D1D13ZZ\F 99~~  4 As334rec4|dk(rd}nd}t||S)z&Sort a list of ``(expr, exp)`` pairs. r)c|\}}|jj}|t|t|jt |j |fSrrgr=rrVrprPrrDexprgs rarkz_sorted_factors..keysCID#((""$CS3tyy>3t{{3CSI Irdc|\}}|jj}t|t|j|t |j |fSrrrs rarkz_sorted_factors..keysCID#((""$CHc$))nc3t{{3CSI Irdrj)ru)rmethodrks ra_sorted_factorsrs$  J  J 's ##rdcft|Dcgc]\}}|j|zc}}Scc}}w)z*Multiply a list of ``(expr, exp)`` pairs. )rrZ)rr\rRs ra_factors_productrs) G4DAqa4 554s- c tjg}}tj|Dcgc] }t |dr|j n|"}}|D]}|j st|trt|r||z}1|jrj|jtjk7rM|j\}} |j r| j r||z}|j r&|j|| f|tj} } t||\} } t!| |dz} | \} }| tjurV| j"r || | zz}nA| j$r|j| | fn!|j| tjf| tjur|j'|o| j(r+|j'|Dcgc] \}}||| zfc}}g}|D]I\}|j+j$r|j|| zf7|j|fK|jt-|| f|dk(r<|D chc]\} }| c}} Dcgc]t3t4fd|Df}}||fScc}wcc}}w#t.$r(}|j|j0| fYd}~d}~wwxYwcc}} wcc}w)z.Helper function for :func:`_symbolic_factor`. _eval_factor_listNr)c34K|]\}}|k(s |ywrr)rtr\rrRs raruz(_symbolic_factor_list..+s Atq!!q& As )rrr make_argsrrrArSr ris_PowbaseExp1r{r3r&rYr~ is_positiver5 is_integerrZrr<rrr)rr|rrrrr{argrrrDrr`_coeff_factorsr\rRrr|s ` ra_symbolic_factor_listrsUUB7Et$ & !(> :ANN  A &D &,? ==ZT2|C7H SLE  ZZCHH.ID#~~#-- ~~c{+QUU#D ?%dC0GD!4'!12D#v FHQUU">>VS[(E''NNFC=1OOVQUUO4aee|x(x@tq!AcE @A$-DAqyy{..1S5z2 aV, -  0 7=>Y,?Z+2341aQ353 Aw ABAF55 '>g &H A#" , NNCHHc? + + ,<45s/%J.J9J3 3 K-"K39 K*K%%K*c t|trOt|dr|jSt t ||d||\}}t |t|St|dr2|j|jDcgc]}t|||c}St|dr*|j|Dcgc]}t|||c}S|Scc}wcc}w)z%Helper function for :func:`_factor`. rfraction)rr{r) rSr rrrrErrr`r{_symbolic_factorr)rr|rrrrs rarr1s$ 4 '$$& &.xs:/WY\^dew5"27";<< v tyyS#+Cf=STT z "~~TRc/S&ARSS TRs C9Ccftj|ddgtj||}t|}t |t t frHt |t r|d}}nt|j\}}t|||\}}t|||\} } | r|jstd|z|jddi} || fD];} t| D]+\} \}}|jrt|| \}}||f| | <-=t!||}t!| |} |j"sH|Dcgc]\}}|j%|f}}}| Dcgc]\}}|j%|f} }}|| z }|js||fS||| fStd|zcc}}wcc}}w)z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrOrza polynomial expected, got %sr)T)rlrIrmr"rSr rTrErrrr9clonerrvr&rrOrZ)rrVr{rr|numerrrfprfq_optrrr\rRrrs ra_generic_factor_listr@s $ 12   d +C 4=D$t % dD !5E#D>88:LE5&uc6:B&uc6:B chh!"AD"HI Iyy(D)*Bx (G&w/ ( 6Aqyy*1d3DAq"#QGAJ ( ( R ( R (yy/12tq!199;"2B2/12tq!199;"2B22xx"9 "b= =DEE32s <F' F-c|jdd}tj|gtj||}||d<t t |||S)z4Helper function for :func:`sqf` and :func:`factor`. rT)rrlrIrmrr")rrVr{rrr|s ra_generic_factorrlsPxx D)H $#   d +CC O GDM3 77rdcddlmd fd }d fd }d}|jjrI||rA|j }|||}|r|d|dd|dfS|||}|r dd|d|dfSy) a! try to transform a polynomial to have rational coefficients try to find a transformation ``x = alpha*y`` ``f(x) = lc*alpha**n * g(y)`` where ``g`` is a polynomial with rational coefficients, ``lc`` the leading coefficient. If this fails, try ``x = y + beta`` ``f(x) = g(y)`` Returns ``None`` if ``g`` not found; ``(lc, alpha, None, g)`` in case of rescaling ``(None, None, beta, g)`` in case of translation Notes ===== Currently it transforms only polynomials without roots larger than 2. Examples ======== >>> from sympy import sqrt, Poly, simplify >>> from sympy.polys.polytools import to_rational_coeffs >>> from sympy.abc import x >>> p = Poly(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))}), x, domain='EX') >>> lc, r, _, g = to_rational_coeffs(p) >>> lc, r (7 + 5*sqrt(2), 2 - 2*sqrt(2)) >>> g Poly(x**3 + x**2 - 1/4*x - 1/4, x, domain='QQ') >>> r1 = simplify(1/r) >>> Poly(lc*r**3*(g.as_expr()).subs({x:x*r1}), x, domain='EX') == p True rsimplifyNct|jdk(r|jdjsd|fS|j}|j }|xs|j }|j dd}|Dcgc] } | }}t|dkDr|dr |d|dz }g}tt|D]5} ||||dzzz}|jsy|j|7 d|z } |jd} | |zg} td|dzD]"}| j||dz | ||z zz$t| }t|}|| |fSycc}w)a$ try rescaling ``x -> alpha*x`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the rescaling is successful, ``alpha`` is the rescaling factor, and ``f`` is the rescaled polynomial; else ``alpha`` is ``None``. rrNr) rrVrrrrr1rrzr3r rT) r\f1r*rrcoeffx rescale1_xcoeffs1r rescale_xrr2rs ra _try_rescalez(to_rational_coeffs.._try_rescales166{aq ':':7N HHJ TTV  288:$178v(6"88 v;?vbz!&*VBZ"78JG3v;' (!&)JQ,?"?@))v& ( %Qz\2 FF1ITFq!a%8AHHWQU^AAJ678GG9a''%9sE2ct|jdk(r|jdjsd|fS|j}|xs|j }|j dd} |d}|j rP|jsDt|jdd\}}|j| |z }|j|}||fSy)a+ try translating ``x -> x + alpha`` to convert f to a polynomial with rational coefficients. Returns ``alpha, f``; if the translating is successful, ``alpha`` is the translating factor, and ``f`` is the shifted polynomial; else ``alpha`` is ``None``. rrNc|jduSr ry)zs rariz._try_translate..s!--4/rdTbinary) rrVrrrr1is_AddrzrLr{r`r) r\rr*rrratnonratalphaf2rs ra_try_translatez*to_rational_coeffs.._try_translates166{aq ':':7N HHJ  288:$ VAY  88AMMqvv/>KCQVVV_$Q&E%B"9 rdc|j}d}|D]}tj|D]}t|j}|j Dcgc]8\}}|j r'|jr|jdk\r |j:}}}|snt|dk(rd}t|dkDsy|Scc}}w)zS Return True if ``f`` is a sum with square roots but no other root FrT) rr rrrrr is_Rationalrtminr) rrhas_sqrrr\rwxrus ra_has_square_rootsz-to_rational_coeffs.._has_square_rootss !A]]1% !AJ&&'(wwyBeaKKBNNrttqyTTBBq6Q;!Fq6A:  ! ! Bs=C rrr)sympy.simplify.simplifyrrrr)r\rrrrrurs @rato_rational_coeffsrusL1 D,& ||~ 1! 4 WWY B  Q41tQqT) )q"%AT1Q41-- rdc ddlm}t||d}|j}t |}|sy|\}}}} t | j } |re|| d|z||zz} |d|z } g} | dddD]5}| j||dj||| zi|df7| | fS| d} g} | dddD]/}| j|dj|||z i|df1| | fS)a helper function to factor polynomial using to_rational_coeffs Examples ======== >>> from sympy.polys.polytools import _torational_factor_list >>> from sympy.abc import x >>> from sympy import sqrt, expand, Mul >>> p = expand(((x**2-1)*(x-2)).subs({x:x*(1 + sqrt(2))})) >>> factors = _torational_factor_list(p, x); factors (-2, [(-x*(1 + sqrt(2))/2 + 1, 1), (-x*(1 + sqrt(2)) - 1, 1), (-x*(1 + sqrt(2)) + 1, 1)]) >>> expand(factors[0]*Mul(*[z[0] for z in factors[1]])) == p True >>> p = expand(((x**2-1)*(x-2)).subs({x:x + sqrt(2)})) >>> factors = _torational_factor_list(p, x); factors (1, [(x - 2 + sqrt(2), 1), (x - 1 + sqrt(2), 1), (x + 1 + sqrt(2), 1)]) >>> expand(factors[0]*Mul(*[z[0] for z in factors[1]])) == p True rrEXr$Nr) rrrTrrrrZr3r)rrrp1r*resrrurr]rrr1rrs ra_torational_factor_listrs,,1 a4 B A R C KB1a!))+&G WQZ]1a4' ( ac] Q =A HHhqtyy!QrT34ad; < = q6M AJ Q 4A HHadiiAE +QqT2 3 4 q6Mrdc t|||dS)z Compute a list of square-free factors of ``f``. Examples ======== >>> from sympy import sqf_list >>> from sympy.abc import x >>> sqf_list(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) (2, [(x + 1, 2), (x + 2, 3)]) r)rrrs rarr s 4e <>> from sympy import sqf >>> from sympy.abc import x >>> sqf(2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16) 2*(x + 1)**2*(x + 2)**3 r)r)rrs rar)r)2s 1dD 77rdc t|||dS)a  Compute a list of irreducible factors of ``f``. Examples ======== >>> from sympy import factor_list >>> from sympy.abc import x, y >>> factor_list(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) (2, [(x + y, 1), (x**2 + 1, 2)]) r{rrrs rarrDs 4h ??rd)rct|}|ryfd}t||}i}|jtt}|D]5}t |gi}|j s |js+||k7s1|||<7|j|S t|dS#t$r|js t|cYSwxYw)a Compute the factorization of expression, ``f``, into irreducibles. (To factor an integer into primes, use ``factorint``.) There two modes implemented: symbolic and formal. If ``f`` is not an instance of :class:`Poly` and generators are not specified, then the former mode is used. Otherwise, the formal mode is used. In symbolic mode, :func:`factor` will traverse the expression tree and factor its components without any prior expansion, unless an instance of :class:`~.Add` is encountered (in this case formal factorization is used). This way :func:`factor` can handle large or symbolic exponents. By default, the factorization is computed over the rationals. To factor over other domain, e.g. an algebraic or finite field, use appropriate options: ``extension``, ``modulus`` or ``domain``. Examples ======== >>> from sympy import factor, sqrt, exp >>> from sympy.abc import x, y >>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2 >>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I) >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) >>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1) By default, factor deals with an expression as a whole: >>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1) If the ``deep`` flag is True then subexpressions will be factored: >>> factor(eq, deep=True) 2**((x + 1)**2) If the ``fraction`` flag is False then rational expressions will not be combined. By default it is True. >>> factor(5*x + 3*exp(2 - 7*x), deep=True) (5*x*exp(7*x) + 3*exp(2))*exp(-7*x) >>> factor(5*x + 3*exp(2 - 7*x), deep=True, fraction=False) 5*x + 3*exp(2)*exp(-7*x) See Also ======== sympy.ntheory.factor_.factorint cZt|gi}|js |jr|S|S)zS Factor, but avoid changing the expression when unable to. )r{is_Mulr)rrwr{rVs ra _try_factorzfactor.._try_factors0---CzzSZZ Krdr{r) r"r%atomsrr r{rrxreplacerr9rr) r\rrVr{rpartialsmuladdrrws `` rar{r{VsH  A   a %c" "A*T*T*C cjjcQh!  "zz(##q$X>> Q<   s B B=;B=c t|ds# t|}|j||||||St |d\}} t | j dkDrtt|D]"\} } | jj|| <$|+| jj|}|dkr td|| jj|}|| jj|}t|| j|||||} g} | D]S\\}}}| jj|| jj|}}| j!||f|fU| S#t$rgcYSwxYw) a/ Compute isolating intervals for roots of ``f``. Examples ======== >>> from sympy import intervals >>> from sympy.abc import x >>> intervals(x**2 - 3) [((-2, -1), 1), ((1, 2), 1)] >>> intervals(x**2 - 3, eps=1e-2) [((-26/15, -19/11), 1), ((19/11, 26/15), 1)] rr$r*r$rrr")r%r&r'rr()rrTr8r#r/rrVr:rrgr=rPrrrFrr3)rrr%r&r'rr(r)rOr|rrDr#r_rrrs rar#r#s" 1j ! QA{{s#Dc{RR,Qt< s sxx=1 - - ' *GAtxx'')E!H * ?**$$S)Cax !DEE ?**$$S)C ?**$$S)C/szz#f4A ( -OFQG::&&q)3::+>+>q+AqA MMAq67+ , - C  I s E-- E;:E;c t|}t|ts!|jjs t d|j ||||||S#t $rt d|zwxYw)z Refine an isolating interval of a root to the given precision. Examples ======== >>> from sympy import refine_root >>> from sympy.abc import x >>> refine_root(x**2 - 3, 1, 2, eps=1e-2) (19/11, 26/15) generator must be a Symbolz,Cannot refine a root of %s, not a polynomial)r%r:r(r<)rTrSr is_Symbolr9r8r9)r\rrr%r:r(r<rs rar9r9sz @ G!T"155??"">? ? ==A3e$)= TT @ :Q >@ @@s >> from sympy import count_roots, I >>> from sympy.abc import x >>> count_roots(x**4 - 4, -3, 3) 2 >>> count_roots(x**4 - 4, 0, 1 + 3*I) 1 Fgreedyrz*Cannot count roots of %s, not a polynomialrA)rTrSrrr9r8rJ)r\r&r'rs rarJrJso(P 5 !!T"155??"">? ? ==Sc= ** PJQNOOP >AA+Tc t|d}t|ts!|jjs t d|j ||S#t $rt d|zwxYw)a, Returns the real and complex roots of ``f`` with multiplicities. Explanation =========== Finds all real and complex roots of a univariate polynomial with rational coefficients of any degree exactly. The roots are represented in the form given by :func:`~.rootof`. This is equivalent to using :func:`~.rootof` to find each of the indexed roots. Examples ======== >>> from sympy import all_roots >>> from sympy.abc import x, y >>> print(all_roots(x**3 + 1)) [-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2] Simple radical formulae are used in some cases but the cubic and quartic formulae are avoided. Instead most non-rational roots will be represented as :class:`~.ComplexRootOf`: >>> print(all_roots(x**3 + x + 1)) [CRootOf(x**3 + x + 1, 0), CRootOf(x**3 + x + 1, 1), CRootOf(x**3 + x + 1, 2)] All roots of any polynomial with rational coefficients of any degree can be represented using :py:class:`~.ComplexRootOf`. The use of :py:class:`~.ComplexRootOf` bypasses limitations on the availability of radical formulae for quintic and higher degree polynomials _[1]: >>> p = x**5 - x - 1 >>> for r in all_roots(p): print(r) CRootOf(x**5 - x - 1, 0) CRootOf(x**5 - x - 1, 1) CRootOf(x**5 - x - 1, 2) CRootOf(x**5 - x - 1, 3) CRootOf(x**5 - x - 1, 4) >>> [r.evalf(3) for r in all_roots(p)] [1.17, -0.765 - 0.352*I, -0.765 + 0.352*I, 0.181 - 1.08*I, 0.181 + 1.08*I] Irrational algebraic or transcendental coefficients cannot currently be handled by :func:`all_roots` (or :func:`~.rootof` more generally): >>> from sympy import sqrt, expand >>> p = expand((x - sqrt(2))*(x - sqrt(3))) >>> print(p) x**2 - sqrt(3)*x - sqrt(2)*x + sqrt(6) >>> all_roots(p) Traceback (most recent call last): ... NotImplementedError: sorted roots not supported over EX In the case of algebraic or transcendental coefficients :func:`~.ground_roots` might be able to find some roots by factorisation: >>> from sympy import ground_roots >>> ground_roots(p, x, extension=True) {sqrt(2): 1, sqrt(3): 1} If the coefficients are numeric then :func:`~.nroots` can be used to find all roots approximately: >>> from sympy import nroots >>> nroots(p, 5) [1.4142, 1.732] If the coefficients are symbolic then :func:`sympy.polys.polyroots.roots` or :func:`~.ground_roots` should be used instead: >>> from sympy import roots, ground_roots >>> p = x**2 - 3*x*y + 2*y**2 >>> roots(p, x) {y: 1, 2*y: 1} >>> ground_roots(p, x) {y: 1, 2*y: 1} Parameters ========== f : :class:`~.Expr` or :class:`~.Poly` A univariate polynomial with rational (or ``Float``) coefficients. multiple : ``bool`` (default ``True``). Whether to return a ``list`` of roots or a list of root/multiplicity pairs. radicals : ``bool`` (default ``True``) Use simple radical formulae rather than :py:class:`~.ComplexRootOf` for some irrational roots. Returns ======= A list of :class:`~.Expr` (usually :class:`~.ComplexRootOf`) representing the roots is returned with each root repeated according to its multiplicity as a root of ``f``. The roots are always uniquely ordered with real roots coming before complex roots. The real roots are in increasing order. Complex roots are ordered by increasing real part and then increasing imaginary part. If ``multiple=False`` is passed then a list of root/multiplicity pairs is returned instead. If ``radicals=False`` is passed then all roots will be represented as either rational numbers or :class:`~.ComplexRootOf`. See also ======== Poly.all_roots: The underlying :class:`Poly` method used by :func:`~.all_roots`. rootof: Compute a single numbered root of a univariate polynomial. real_roots: Compute all the real roots using :func:`~.rootof`. ground_roots: Compute some roots in the ground domain by factorisation. nroots: Compute all roots using approximate numerical techniques. sympy.polys.polyroots.roots: Compute symbolic expressions for roots using radical formulae. References ========== .. [1] https://en.wikipedia.org/wiki/Abel%E2%80%93Ruffini_theorem Frr1Cannot compute real roots of %s, not a polynomialrUrM)rTrSrrr9r8rZr\rUrMrs rarZrZ/svB E 5 !!T"155??"">? ? ;;8; << E ?! CE EErc t|d}t|ts!|jjs t d|j ||S#t $rt d|zwxYw)a Returns the real roots of ``f`` with multiplicities. Explanation =========== Finds all real roots of a univariate polynomial with rational coefficients of any degree exactly. The roots are represented in the form given by :func:`~.rootof`. This is equivalent to using :func:`~.rootof` or :func:`~.all_roots` and filtering out only the real roots. However if only the real roots are needed then :func:`real_roots` is more efficient than :func:`~.all_roots` because it computes only the real roots and avoids costly complex root isolation routines. Examples ======== >>> from sympy import real_roots >>> from sympy.abc import x, y >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4, multiple=False) [(-1/2, 1), (2, 2)] Real roots of any polynomial with rational coefficients of any degree can be represented using :py:class:`~.ComplexRootOf`: >>> p = x**9 + 2*x + 2 >>> print(real_roots(p)) [CRootOf(x**9 + 2*x + 2, 0)] >>> [r.evalf(3) for r in real_roots(p)] [-0.865] All rational roots will be returned as rational numbers. Roots of some simple factors will be expressed using radical or other formulae (unless ``radicals=False`` is passed). All other roots will be expressed as :class:`~.ComplexRootOf`. >>> p = (x + 7)*(x**2 - 2)*(x**3 + x + 1) >>> print(real_roots(p)) [-7, -sqrt(2), CRootOf(x**3 + x + 1, 0), sqrt(2)] >>> print(real_roots(p, radicals=False)) [-7, CRootOf(x**2 - 2, 0), CRootOf(x**3 + x + 1, 0), CRootOf(x**2 - 2, 1)] All returned root expressions will numerically evaluate to real numbers with no imaginary part. This is in contrast to the expressions generated by the cubic or quartic formulae as used by :func:`~.roots` which suffer from casus irreducibilis [1]_: >>> from sympy import roots >>> p = 2*x**3 - 9*x**2 - 6*x + 3 >>> [r.evalf(5) for r in roots(p, multiple=True)] [5.0365 - 0.e-11*I, 0.33984 + 0.e-13*I, -0.87636 + 0.e-10*I] >>> [r.evalf(5) for r in real_roots(p, x)] [-0.87636, 0.33984, 5.0365] >>> [r.is_real for r in roots(p, multiple=True)] [None, None, None] >>> [r.is_real for r in real_roots(p)] [True, True, True] Using :func:`real_roots` is equivalent to using :func:`~.all_roots` (or :func:`~.rootof`) and filtering out only the real roots: >>> from sympy import all_roots >>> r = [r for r in all_roots(p) if r.is_real] >>> real_roots(p) == r True If only the real roots are wanted then using :func:`real_roots` is faster than using :func:`~.all_roots`. Using :func:`real_roots` avoids complex root isolation which can be a lot slower than real root isolation especially for polynomials of high degree which typically have many more complex roots than real roots. Irrational algebraic or transcendental coefficients cannot be handled by :func:`real_roots` (or :func:`~.rootof` more generally): >>> from sympy import sqrt, expand >>> p = expand((x - sqrt(2))*(x - sqrt(3))) >>> print(p) x**2 - sqrt(3)*x - sqrt(2)*x + sqrt(6) >>> real_roots(p) Traceback (most recent call last): ... NotImplementedError: sorted roots not supported over EX In the case of algebraic or transcendental coefficients :func:`~.ground_roots` might be able to find some roots by factorisation: >>> from sympy import ground_roots >>> ground_roots(p, x, extension=True) {sqrt(2): 1, sqrt(3): 1} If the coefficients are numeric then :func:`~.nroots` can be used to find all roots approximately: >>> from sympy import nroots >>> nroots(p, 5) [1.4142, 1.732] If the coefficients are symbolic then :func:`sympy.polys.polyroots.roots` or :func:`~.ground_roots` should be used instead. >>> from sympy import roots, ground_roots >>> p = x**2 - 3*x*y + 2*y**2 >>> roots(p, x) {y: 1, 2*y: 1} >>> ground_roots(p, x) {y: 1, 2*y: 1} Parameters ========== f : :class:`~.Expr` or :class:`~.Poly` A univariate polynomial with rational (or ``Float``) coefficients. multiple : ``bool`` (default ``True``). Whether to return a ``list`` of roots or a list of root/multiplicity pairs. radicals : ``bool`` (default ``True``) Use simple radical formulae rather than :py:class:`~.ComplexRootOf` for some irrational roots. Returns ======= A list of :class:`~.Expr` (usually :class:`~.ComplexRootOf`) representing the real roots is returned. The roots are arranged in increasing order and are repeated according to their multiplicities as roots of ``f``. If ``multiple=False`` is passed then a list of root/multiplicity pairs is returned instead. If ``radicals=False`` is passed then all roots will be represented as either rational numbers or :class:`~.ComplexRootOf`. See also ======== Poly.real_roots: The underlying :class:`Poly` method used by :func:`real_roots`. rootof: Compute a single numbered root of a univariate polynomial. all_roots: Compute all real and non-real roots using :func:`~.rootof`. ground_roots: Compute some roots in the ground domain by factorisation. nroots: Compute all roots using approximate numerical techniques. sympy.polys.polyroots.roots: Compute symbolic expressions for roots using radical formulae. References ========== .. [1] https://en.wikipedia.org/wiki/Casus_irreducibilis Frrr r )rTrSrrr9r8rWr s rarWrWsv~ E 5 !!T"155??"">? ? <<H< == E ?! CE EErc t|d}t|ts!|jjs t d|j |||S#t $rt d|zwxYw)aL Compute numerical approximations of roots of ``f``. Examples ======== >>> from sympy import nroots >>> from sympy.abc import x >>> nroots(x**2 - 3, n=15) [-1.73205080756888, 1.73205080756888] >>> nroots(x**2 - 3, n=30) [-1.73205080756887729352744634151, 1.73205080756887729352744634151] Frrz6Cannot compute numerical roots of %s, not a polynomial)r*r_r`)rTrSrrr9r8rx)r\r*r_r`rs rarxrxksw" J 5 !!T"155??"">? ? 88a(G8 << J Dq HJ JJs >AA,ctj|g t|g|i|\}}t|ts!|j j s td|jS#t$r}tdd|d}~wwxYw)z Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import ground_roots >>> from sympy.abc import x >>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2} rr|rN) rlrIr'rSrTrrr9r<r=r|rLs rar|r|s $#81D1D13!T"155??"">? ? >>  83778sAA++ B4 BBcPtj|g t|g|i|\}}t|ts!|j j s td|j|}|js|jS|S#t$r}tdd|d}~wwxYw)a Construct a polynomial with n-th powers of roots of ``f``. Examples ======== >>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x >>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2)) >>> g (x**2 - x + 1)**2 >>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys() >>> set(R_f) == set(R_g) True rrrN) rlrIr'rSrTrrr9r<r=rrOrZ)r\r*rVr{rr|r|r_s rarrs0 $#@1D1D13!T"155??"">? ? # #A &F 99~~  @ 63??@sAB B% B  B%) _signsimpcddlm}ddlm}t j |dgt |}|r||}i}d|vr|d|d<t|ttfsO|js t|tst|ts|St|d}|j\}}nt|dk(ry|\}}t|t rCt|t r3|j"|d<|j$|d <|j'dd|d<|j)|j)}}n)t|tr t|St+d |zdd lm |j1r t3|||fg|i|\} \} } | j4s9t|ttfs|j7St8j:||fS d| jG| c} \}}|j'ddrd|vr| jZ|d<t|ttfs$| |j)|j)z zS|j)|j)}}|j'dds| ||fS| t!|g|i|t!|g|i|fS#t2$rE} |j<r|j1s t3| |j>s |j@rjtC|jDfd d \} }|Dcgc] }tG|ncc}w}}|jHtG|jH| g|cYd} ~ Sg}tK|}tM||D]Z}t|tttNfr |jQ|tG|f|jSM#tT$rYXwxYw|jWtY|cYd} ~ Sd} ~ wwxYw)a[ Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol, together >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2 Note: due to automatic distribution of Rationals, a sum divided by an integer will appear as a sum. To recover a rational form use `together` on the result: >>> cancel(x/2 + 1) x/2 + 1 >>> together(_) (x + 2)/2 r)signsimp)sringrOT)radicalrrVrPzunexpected argument: %sr1cH|jduxr|j Sr )rhas)rr2s rarizcancel..s'  D(Ay1A-ArdrNrF).rrsympy.polys.ringsrrlrIr"rSr7r rArr rrrrTrVrPrrZrr4r2rr9ngensr)rrrrrrLr{rr`r$rCr&r3skiprnrrqr)r\rrVr{rrr|rrtrrrmsgrncrr;poter rr2s @rarrst21' $ * A QK C$G}G a% ( ;;*Q 3:a;NH D )!1 Q11 a :a#6&&CKHHCM777D1CLyy{AIIK1 Au A2Q677> * 55 !# #1a&04040 6Aqwwa%0xxz!uua{" <188A;IAv1 www6#4iiF a% (!))+aiik)**yy{AIIK1www&a7Nd1+t+s+T!-Bd-Bc-BB BI *  AEE)$4!#& & 88qxx"BEAr&((&)((B(166&,2r2 2D$Q'C I a% !<=KKF1I/HHJ* ::d4j) )/*sb$A J%J%% O4/A"O/L$#0O/O49O/,O?O/ O  O/ O  O/)O4/O4cZtj|ddg t|gt|zg|i|\}}|j }d}|jr;|jr/|js#|jd|ji}d}dd l m } | |j|j |j\} } t!|D]L\} } | j#|j j$j'} | j)| || <N|dj+|d d\}}|Dcgc]!}t,j/t1||#}}t,j/t1||}|r3 |Dcgc]}|j3c}|j3}}||}}|j6s.|Dcgc]}|j9c}|j9fS||fS#t$r}t dd|d}~wwxYwcc}wcc}w#t4$rYqwxYwcc}w) a< Reduces a polynomial ``f`` modulo a set of polynomials ``G``. Given a polynomial ``f`` and a set of polynomials ``G = (g_1, ..., g_n)``, computes a set of quotients ``q = (q_1, ..., q_n)`` and the remainder ``r`` such that ``f = q_1*g_1 + ... + q_n*g_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> from sympy import reduced >>> from sympy.abc import x, y >>> reduced(2*x**4 + y**2 - x**2 + y**3, [x**3 - x, y**3 - y]) ([2*x, 1], x**2 + y**2 + y) rOrreducedrNFrPTxringr)rlrIr/rtr<r=rPrrrrrrr!rVrirrrgrrr~rTrrrqrr6rOrZ)r\rrVr{rOr|r|rPr%r!_ringrrrDrrurt_Q_rs rarr;s( $& 123,aS47]JTJTJ sZZFG xxFNN6??ii6#3#3#567'SXXszz3995HE1U#)4szz*..668??4(a) 8<<ab "DAq0121a# &2A2 Q%A +,-aaiik-qyy{BrqA 99%&' '44!t C 3 1c223& 3 .    (sGG17&HHHHH(1 H : HH H H%$H%c t|g|i|S)a Computes the reduced Groebner basis for a set of polynomials. Use the ``order`` argument to set the monomial ordering that will be used to compute the basis. Allowed orders are ``lex``, ``grlex`` and ``grevlex``. If no order is specified, it defaults to ``lex``. For more information on Groebner bases, see the references and the docstring of :func:`~.solve_poly_system`. Examples ======== Example taken from [1]. >>> from sympy import groebner >>> from sympy.abc import x, y >>> F = [x*y - 2*y, 2*y**2 - x**2] >>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex') By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using the ``method`` flag or with the :func:`sympy.polys.polyconfig.setup` function. >>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)] >>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') References ========== 1. [Buchberger01]_ 2. [Cox97]_ ) GroebnerBasisrrVr{s rar.r.wsf  *T *T **rdc4t|g|i|jS)a[ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 )r&is_zero_dimensionalr's rar)r)s  *T *T * > >>rdceZdZdZdZedZedZedZ edZ edZ edZ ed Z d Zd Zd Zd ZdZdZedZdZddZdZy)r&z%Represents a reduced Groebner basis. c"tj|ddg t|g|i|\}}ddlm}||j|j|j}|D cgc].} | s|j| jj0}} t|||j} | D cgc]} t j#| |} } |j%| |S#t$r}t dt ||d}~wwxYwcc} wcc} w)z>Compute a reduced Groebner basis for a system of polynomials. rOrr.Nr)PolyRingr)rlrIr/r<r=rrr,rVrPrirrgr _groebnerrrTrr_new) rzrrVr{rOr|r|r,ringrDrr]s rar}zGroebnerBasis.__new__sdWh$78 =0BTBTBJE3 /#**cii8@EN 0 0 23NN eT#** 5./ 0T__Q $ 0 0xx3" =#JA< < = O 1s)C D&+D/D  D)C??Dc^tj|}t||_||_|Sr)r r}r7_basis_options)rzbasisrlrs rar.zGroebnerBasis._news'mmC 5\   rdcpd|jD}t|t|jjfS)Nc3<K|]}|jywrr)rtrs raruz%GroebnerBasis.args..s22s)r1r r2rV)rr3s rar{zGroebnerBasis.argss.2dkk2u udmm&8&89::rdc\|jDcgc]}|jc}Scc}wr)r1rZrrDs rar.zGroebnerBasis.exprss +/;;74 777s)c,t|jSr)rtr1rs rarOzGroebnerBasis.polyssDKK  rdc.|jjSr)r2rVrs rarVzGroebnerBasis.genss}}!!!rdc.|jjSr)r2rPrs rarPzGroebnerBasis.domains}}###rdc.|jjSr)r2rirs rarizGroebnerBasis.orders}}"""rdc,t|jSr)rr1rs ra__len__zGroebnerBasis.__len__s4;;rdc|jjrt|jSt|jSr)r2rOiterr.rs rarzGroebnerBasis.__iter__s- ==   # # # #rdcr|jjr|j}||S|j}||Sr)r2rOr.)ritemr3s ra __getitem__zGroebnerBasis.__getitem__s9 ==  JJET{JJET{rdcrt|jt|jj fSr)hashr1r7r2rrs rarzGroebnerBasis.__hash__ s(T[[% (;(;(=">?@@rdct||jr4|j|jk(xr|j|jk(St |r2|j t |k(xs|jt |k(Sy)NF)rSrr1r2rKrOrtr.rrs rarzGroebnerBasis.__eq__ sd eT^^ ,;;%,,.R4==ENN3R R e_::e,I d5k0I Irdc||k( SrrrFs rarzGroebnerBasis.__ne__s5=  rdcd}tdgt|jz}|jj}|j D]"}|j |}||s||z}$t|S)a{ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 c:ttt|dk(Sr)sumrr6)monomials ra single_varz5GroebnerBasis.is_zero_dimensional..single_var&ss4*+q0 0rdrr,)r/rrVr2rirOrr)rrLrrirDrKs rar)z!GroebnerBasis.is_zero_dimensionalsr 1aSTYY/0  ##JJ &DwwUw+H(#X%  &9~rdc |j}|j}t|}||k(r|S|js t dt |j }|j}|j|j|d}ddl m }||j|j|\}} t|D]L\} } | j|jjj!} |j#| || <Nt%|||} | D cgc]!} t&j)t+| |#} } |j,s)| D cgc]} | j/dd} } ||_|j1| |Scc} wcc} w)a Convert a Groebner basis from one ordering to another. The FGLM algorithm converts reduced Groebner bases of zero-dimensional ideals from one ordering to another. This method is often used when it is infeasible to compute a Groebner basis with respect to a particular ordering directly. Examples ======== >>> from sympy.abc import x, y >>> from sympy import groebner >>> F = [x**2 - 3*y - x + 1, y**2 - 2*x + y - 1] >>> G = groebner(F, x, y, order='grlex') >>> list(G.fglm('lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] >>> list(groebner(F, x, y, order='lex')) [2*x - y**2 - y + 1, y**4 + 2*y**3 - 3*y**2 - 16*y + 7] References ========== .. [1] J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering z?Cannot convert Groebner bases of ideals with positive dimension)rPrirr Trr)r2rir0r)rnrtr1rPrrrr!rVrrrgrrr-rTrrrqrrr.)rrir| src_order dst_orderrOrPr!r"rrrDrr]s rafglmzGroebnerBasis.fglm7sc>mmII  '  !K''%&gh hT[[!ii&&(   ,3::y9q ' -GAt??3::.22::>> from sympy import groebner, expand >>> from sympy.abc import x, y >>> f = 2*x**4 - x**2 + y**3 + y**2 >>> G = groebner([x**3 - x, y**3 - y]) >>> G.reduce(f) ([2*x, 1], x**2 + y**2 + y) >>> Q, r = _ >>> expand(sum(q*g for q, g in zip(Q, G)) + r) 2*x**4 - x**2 + y**3 + y**2 >>> _ == f True FrPTrr rN)rTrxr2rtr1rPrrrrrr!rVrirrrgrrr~rrrqrr6rOrZ)rrrrDrOr|rPr%r!r"rrrrurtr#r$s rarzGroebnerBasis.reduceys8tT]]3dkk**mm FNN6??))Xv'7'7'9:;CG+3::syy9q ' -GAt??3::.22::G9G>H 9G>> H  H c0|j|ddk(S)am Check if ``poly`` belongs the ideal generated by ``self``. Examples ======== >>> from sympy import groebner >>> from sympy.abc import x, y >>> f = 2*x**3 + y**3 + 3*y >>> G = groebner([x**2 + y**2 - 1, x*y - 2]) >>> G.contains(f) True >>> G.contains(f + 1) False rr)rr7s racontainszGroebnerBasis.containss&{{4 #q((rdNr )r[rrrr}rr.rr{r.rOrVrPrir=rrBrrrr)rPrrSrrdrar&r&s/ &;;88!!""$$## $ A!>@!D?B)rdr&ctjgfdt|}|jrt |g|iSdvrdd<tj |}||S)z Efficiently transform an expression into a polynomial. Examples ======== >>> from sympy import poly >>> from sympy.abc import x >>> poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') c6gg}}tj|D]`}gg}}tj|D]}|jr|j  ||(|j rw|j jra|jjrK|jdk\r<|j  |j |j|j|j ||s|j ||d}|ddD]}|j|}|r?t|}|jr||z}n%|jtj||}|j |c|stj||} na|d} |ddD]}| j|} |r?t|}|jr| |z } n%| jtj||} | j|j!ddi S)NrrrVr)r rrrr3rrrr~rprrArTrxrrr) rr|r poly_termsrr poly_factorsr{productr__polyr{s rarYzpoly.._polyszMM$' +D$&\G--- +== ''fc(:;]]v{{'9'9 --&**/ ''fkk3/33FJJ?ANN6* +  T"&q/*12.2F%kk&1G2 ']F''6)")++doofc.J"K!!'*; +>__T3/F]F"12 *D) *E{>>dNF#ZZc(BCFv~~swwvr2;d;;rdr)F)rlrIr"rvrTrm)rrVr{r|rYs ` @rarDrDsr $#2sympy.polys.polyutilsr?r@rArBrCrDsympy.polys.rationaltoolsrEsympy.polys.rootisolationrFsympy.utilitiesrGrHrIsympy.utilities.exceptionsrJsympy.utilities.iterablesrKrLrNrompmath.libmp.libhyperrMrcrTrr'r&r/r-r?rrrrrrrsrwryr{r~rrrrrrrrrrrrrrrUrrrrrrrrrrrrrrrrrrrrr)rr{r#r9rJrZrWrxr|rrrr)r&rDr^rrdrars>$#,AAMM*+#776&+0>+.4**;-;*.11    /A55@4 /!J|B`5|B`|B`~EZtZZz&& %P00 [|7N7Nt11h((4!!02!!2::DD>>>D##L##L00f:&+!!H:%%PQQh00fJJZ//dr3r3j::0**Z:::++\<<   F: $ 6 7t )FX8|~)X=="88"@@"__D44nUU8++@K=K=\i>i>X==<:((V#cCcCL88v2+2+j??"M)EM)M)`NNb"-rd