B [@sdZddlmZmZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDddlEZFddlGZGddlHmIZIddlJmKZKmLZLmMZMddlNmOZOddlEmPZQddlRmSZSmTZTmUZUeCGdddeZVeCGdddeVZWeCd d!ZXd"d#ZYeCd$d%ZZd&d'Z[d(d)Z\eCdd*d+Z]eCd,d-Z^eCd.d/Z_eCd0d1Z`eCd2d3ZaeCd4d5ZbeCd6d7ZceCd8d9ZdeCd:d;ZeeCdd?ZgeCd@dAZheCdBdCZieCdDdEZjeCdFdGZkeCdHdIZleCdJdKZmeCdLdMZneCdNdOZoeCdPdQZpeCdRdSZqeCdTdUZreCddVdWZseCdXdYZteCddZd[ZueCd\d]ZveCd^d_ZweCd`daZxeCdbdcZyeCdddeZzeCdfdgZ{eCdhdiZ|eCdjdkZ}eCdldmZ~eCdndoZeCdpdqZeCdrdsZdtduZdvdwZdxdyZdzd{Zd|d}Zd~dZddZddZeCddZeCddZeCddZeCddZeCdddZeCdddZeCdddZeCdddZeCdddZeCddZeCddZeCddZeCddZeCddZ,eCddZeCGdddeZeCddZdS)z8User-friendly public interface to polynomial functions. )print_functiondivision) SBasicExprIIntegerAddMulDummyTuple) _keep_coeff)Symbol)preorder_traversal) Relational)sympify) _sympifyit) Derivative) BooleanAtom)DMP)basic_from_dict _sort_gens _unify_gens _dict_reorder_dict_from_expr_parallel_dict_from_expr)together)dup_isolate_real_roots_list)groebner) matrix_fglm)Monomial) monomial_key) OperationNotSupported DomainErrorCoercionFailedUnificationFailedGeneratorsNeededPolynomialErrorMultivariatePolynomialErrorExactQuotientFailedPolificationFailedComputationFailedGeneratorsError)groupsiftpublic filldedentN) NoConvergence)FFQQZZ)construct_domain) polyoptions)iterablerangeorderedcsteZdZdZddgZdZdZdZddZe dd Z e d d Z e d d Z e ddZ e ddZe ddZe ddZe ddZe ddZddZfddZeddZed d!Zed"d#Zed$d%Zed&d'Zed(d)Zed*d+Zed,d-Zd.d/Zd0d1Zdkd3d4Z d5d6Z!d7d8Z"d9d:Z#d;d<Z$d=d>Z%d?d@Z&dldAdBZ'dCdDZ(dEdFZ)dGdHZ*dIdJZ+dKdLZ,dMdNZ-dmdOdPZ.dndQdRZ/dodSdTZ0dpdUdVZ1dqdWdXZ2dYdZZ3d[d\Z4d]d^Z5d_d`Z6dadbZ7drdddeZ8dsdfdgZ9dhdiZ:djdkZ;dldmZ<dtdndoZ=dpdqZ>drdsZ?dtduZ@dvdwZAdxdyZBdzd{ZCd|d}ZDd~dZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOduddZPdvddZQdwddZRdxddZSddZTdyddZUddZVddZWddZXddZYdzddZZddZ[d{ddZ\ddZ]ddZ^d|ddZ_d}ddZ`d~ddZadddZbdddZcddZdddZedddÄZfddńZgddDŽZhddɄZieiZjeiZkddd˄Zldd̈́ZmdddτZndddфZodddӄZpddՄZqddׄZrdddلZsddۄZtddd݄Zuddd߄ZvddZwddZxddZyddZzdddZ{ddZ|ddZ}ddZ~ddZddZddZdddZddZddZddZddZdddZdddZddZddZddd Zdd d Zdd d ZdddZdddZdddZdddZddZddZdddZeddZed d!Zed"d#Zed$d%Zed&d'Zed(d)Zed*d+Zed,d-Zed.d/Zed0d1Zed2d3Zed4d5Zed6d7Zed8d9Zd:d;Zd<d=Zed>ed?d@Zed>edAdBZed>edCdDZed>edEdFZed>edGdHZed>edIdJZedKedLdMZed>edNdOZed>edPdQZed>edRdSZed>edTdUZed>edVdWZed>edXdYZed>edZd[Zed>ed\d]ZeZeZed^ed_d`Zed>edadbZdcddZeZddedfZddgdhZdidjZZS(Polya Generic class for representing and operating on polynomial expressions. Subclasses Expr class. 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 repgensTgn$@cOszt||}d|krtdt|tdrPt|tr>|||S|t ||Sn&t |}|j rj| ||S| ||SdS)z:Create a new polynomial instance out of something useful. orderz&'order' keyword is not implemented yet)excludeN)options build_optionsNotImplementedErrorr7str isinstancedict _from_dict _from_listlistris_Poly _from_poly _from_expr)clsr;r<argsoptrN4lib/python3.7/site-packages/sympy/polys/polytools.py__new__os     z Poly.__new__cGsTt|tstd|n"|jt|dkr:td||ft|}||_||_|S)z:Construct :class:`Poly` instance from raw representation. z%invalid polynomial representation: %szinvalid arguments: %s, %s) rCrr'levlenrrPr;r<)rKr;r<objrNrNrOnews   zPoly.newcOst||}|||S)z(Construct a polynomial from a ``dict``. )r?r@rE)rKr;r<rLrMrNrNrO from_dicts zPoly.from_dictcOst||}|||S)z(Construct a polynomial from a ``list``. )r?r@rF)rKr;r<rLrMrNrNrO from_lists zPoly.from_listcOst||}|||S)z*Construct a polynomial from a polynomial. )r?r@rI)rKr;r<rLrMrNrNrO from_polys zPoly.from_polycOst||}|||S)z+Construct a polynomial from an expression. )r?r@rJ)rKr;r<rLrMrNrNrO from_exprs zPoly.from_exprcCs||j}|stdt|d}|j}|dkr>t||d\}}n$x"|D]\}}||||<qHW|jt |||f|S)z(Construct a polynomial from a ``dict``. z/can't initialize from 'dict' without generatorsrQN)rM) r<r&rSdomainr5itemsconvertrUrrV)rKr;rMr<levelrZmonomcoeffrNrNrOrEs zPoly._from_dictcCs~|j}|stdnt|dkr(tdt|d}|j}|dkrTt||d\}}ntt|j|}|j t |||f|S)z(Construct a polynomial from a ``list``. z/can't initialize from 'list' without generatorsrQz#'list' representation not supportedN)rM) r<r&rSr(rZr5rGmapr\rUrrW)rKr;rMr<r]rZrNrNrOrFs  zPoly._from_listcCs||jkr|j|jf|j}|j}|j}|j}|rj|j|krjt|jt|kr`|||S|j |}d|kr|r| |}n|dkr| }|S)z*Construct a polynomial from a polynomial. rZT) __class__rUr;r<fieldrZsetrJas_exprreorder set_domainto_field)rKr;rMr<rbrZrNrNrOrIs    zPoly._from_polycCst||\}}|||S)z+Construct a polynomial from an expression. )rrE)rKr;rMrNrNrOrJszPoly._from_exprcCs |j|jfS)z$Allow SymPy to hash Poly instances. )r;r<)selfrNrNrO_hashable_contentszPoly._hashable_contentcstt|S)N)superr:__hash__)rh)rarNrOrksz Poly.__hash__cCsVt}|j}x>tt|D].}x(|D]}||r(|||jO}Pq(WqW||jBS)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} )rcr<r8rSmonoms free_symbolsfree_symbols_in_domain)rhsymbolsr<ir^rNrNrOrms zPoly.free_symbolscCsX|jjt}}|jr2x<|jD]}||jO}qWn"|jrTx|D]}||jO}qBW|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} )r;domrc is_Compositerormis_EXcoeffs)rhrZrogenr_rNrNrOrns zPoly.free_symbols_in_domaincCs |fS)z Don't mess up with the core. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).args (x**2 + 1,) )rd)rhrNrNrOrL6sz Poly.argscCs |jdS)z Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x r)r<)rhrNrNrOruGszPoly.gencCs|S)z#Get the ground domain of ``self``. ) get_domain)rhrNrNrOrZXsz Poly.domaincCs$|j|j|jj|jjf|jS)z3Return zero polynomial with ``self``'s properties. )rUr;zerorRrqr<)rhrNrNrOrw]sz Poly.zerocCs$|j|j|jj|jjf|jS)z2Return one polynomial with ``self``'s properties. )rUr;onerRrqr<)rhrNrNrOrxbszPoly.onecCs$|j|j|jj|jjf|jS)z3Return unit polynomial with ``self``'s properties. )rUr;unitrRrqr<)rhrNrNrOrygsz Poly.unitcCs"||\}}}}||||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)fg_perFGrNrNrOunifylsz Poly.unifyc stjsZy&jjjjjjjfStk rXtdfYnXtjt rtjt rt j j }jj jj|t |d}j |krtjj |\}}jjkrfdd|D}t ttt|||}n j}j |krttjj |\}}jjkrXfdd|D}t ttt|||} n j} ntdfj|dffdd } | || fS)Nzcan't unify %s with %srQcsg|]}|jjqSrN)r\r;rq).0c)rqr{rNrO szPoly._unify..csg|]}|jjqSrN)r\r;rq)rr)rqr|rNrOrscsB|dk r2|d|||dd}|s2||Sj|f|S)NrQ)to_sympyrU)r;rqr<remove)rKrNrOr~s  zPoly._unify..per)rrHr;rqr~ from_sympyr$r%rCrrr<rrSrto_dictrDrGzipr\ra) r{r|r<rRZf_monomsZf_coeffsrZg_monomsZg_coeffsrr~rN)rKrqr{r|rOrzs6&"     z Poly._unifyNcCsV|dkr|j}|dk rD|d|||dd}|sD|jj|S|jj|f|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') NrQ)r<r;rqrrarU)r{r;r<rrNrNrOr~szPoly.percCs&t|jd|i}||j|jS)z Set the ground domain of ``f``. rZ)r?r@r<r~r;r\rZ)r{rZrMrNrNrOrfszPoly.set_domaincCs|jjS)z Get the ground domain of ``f``. )r;rq)r{rNrNrOrvszPoly.get_domaincCstj|}|t|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) )r?ZModulusZ preprocessrfr2)r{modulusrNrNrO set_moduluss zPoly.set_moduluscCs&|}|jrt|StddS)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 fieldN)rvZis_FiniteFieldrZcharacteristicr')r{rZrNrNrO get_moduluss zPoly.get_moduluscCsN||jkr>|jr|||Sy |||Stk r<YnX|||S)z)Internal implementation of :func:`subs`. )r< is_numberevalreplacer'rdsubs)r{oldrUrNrNrO _eval_subss   zPoly._eval_subscCsP|j\}}g}x.tt|jD]}||kr"||j|q"W|j||dS)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<)r;r>r8rSr<appendr~)r{JrUr<jrNrNrOr>s z Poly.excludecCs|dkr$|jr|j|}}ntd||kr0|S||jkr||jkr|}|jr\||jkrt|j}||||<|j |j |dStd|||fdS)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') Nz(syntax supported only in univariate case)r<zcan't replace %s with %s in %s) is_univariaterur'r<rvrrrorGindexr~r;)r{xyrqr<rNrNrOr+s z Poly.replacecOs|td|}|s t|j|d}nt|jt|kr:tdtttt |j |j|}|j t ||j jt|d|dS)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') rN)rMz7generators list can differ only up to order of elementsrQ)r<)r?ZOptionsrr<rcr'rDrGrrr;rr~rrqrS)r{r<rLrMr;rNrNrOreMs  z Poly.reordercCs|jdd}||}i}xJ|D]>\}}tdd|d|DrRtd|||||d<q$W|j|d}|jt|t |d|j j f|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)nativecss|] }|VqdS)NrN)rrprNrNrO szPoly.ltrim..Nzcan't left trim %srQ) as_dict _gen_to_levelr[anyr'r<rUrrVrSr;rq)r{rur;rtermsr^r_r<rNrNrOltrimgs   z Poly.ltrimc Gst}xL|D]D}y|j|}Wn$tk rDtd||fYq X||q Wx6|D]*}x$t|D]\}}||krl|rldSqlWq^WdS)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 z%s doesn't have %s as generatorFT)rcr<r ValueErrorr,addrl enumerate)r{r<indicesrurr^rpeltrNrNrO has_only_genss   zPoly.has_only_genscCs,t|jdr|j}n t|d||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)hasattrr;rr"r~)r{resultrNrNrOrs   z Poly.to_ringcCs,t|jdr|j}n t|d||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') rg)rr;rgr"r~)r{rrNrNrOrgs   z Poly.to_fieldcCs,t|jdr|j}n t|d||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)rr;rr"r~)r{rrNrNrOrs   z Poly.to_exactcCs4t|jdd||jjpdd\}}|j||j|dS)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') T)rwN)rbZ composite)rZ)r5rrZrrrVr<)r{rbrqr;rNrNrOretracts z Poly.retractcCsh|dkrd||}}}n ||}t|t|}}t|jdrT|j|||}n t|d||S)z1Take a continuous subsequence of terms of ``f``. Nrslice)rintrr;rr"r~)r{rmnrrrNrNrOrs   z Poly.slicecsfddjj|dDS)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 csg|]}jj|qSrN)r;rqr)rr)r{rNrOr(szPoly.coeffs..)r=)r;rt)r{r=rN)r{rOrtsz Poly.coeffscCs|jj|dS)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=)r;rl)r{r=rNrNrOrl*sz Poly.monomscsfddjj|dDS)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 cs"g|]\}}|jj|fqSrN)r;rqr)rrr)r{rNrOrPszPoly.terms..)r=)r;r)r{r=rN)r{rOr>sz Poly.termscsfddjDS)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] csg|]}jj|qSrN)r;rqr)rr)r{rNrOr`sz#Poly.all_coeffs..)r; all_coeffs)r{rN)r{rOrRszPoly.all_coeffscCs |jS)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 )r; all_monoms)r{rNrNrOrbszPoly.all_monomscsfddjDS)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)] cs"g|]\}}|jj|fqSrN)r;rqr)rrr)r{rNrOrsz"Poly.all_terms..)r; all_terms)r{rN)r{rOrvszPoly.all_termscOsvi}xX|D]L\}}|||}t|tr4|\}}n|}|r||krN|||<qtd|qW|j|f|pn|j|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)rrCtupler'rVr<)r{funcr<rLrr^r_rrNrNrOtermwises    z Poly.termwisecCs t|S)z Returns the number of non-zero terms in ``f``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 2*x - 1).length() 3 )rSr)r{rNrNrOlengthsz Poly.lengthFcCs$|r|jj|dS|jj|dSdS)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} )rwN)r;r to_sympy_dict)r{rrwrNrNrOrsz Poly.as_dictcCs|r|jS|jSdS)z%Switch to a ``list`` representation. N)r;Zto_listZ to_sympy_list)r{rrNrNrOas_lists z Poly.as_listc Gs|s |j}n~t|dkrt|dtr|d}t|j}xP|D]D\}}y||}Wn$tk r|td||fYqBX|||<qBWt |j f|S)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 rQrz%s doesn't have %s as generator) r<rSrCrDrGr[rrr,rr;r)r{r<mappingruvaluerrNrNrOrds  z Poly.as_exprcCs,t|jdr|j}n t|d||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)rr;rr"r~)r{rrNrNrOrs   z Poly.liftcCs4t|jdr|j\}}n t|d|||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)rr;rr"r~)r{rrrNrNrOrs  z Poly.deflatecCsx|jj}|jr|S|js$td|t|jdr@|jj|d}n t|d|r\|j|j }n |j |j}|j |f|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') zcan't inject generators over %sinject)front) r;rq is_NumericalrHr#rrr"ror<rU)r{rrqrr<rNrNrOr$s    z Poly.injectcGs|jj}|jstd|t|jt|}}|jd||krV|j|dd}}n4|j| d|kr|jd| d}}ntd|j|}t|jdr|jj ||d}n t |d|j |f|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]') zcan't eject generators over %sNTFz'can only eject front or back generatorseject)r) r;rqrr#rSr<rArrrr"rU)r{r<rqrkZ_gensrrrNrNrOrIs    z Poly.ejectcCs4t|jdr|j\}}n t|d|||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)rr;rr"r~)r{rrrNrNrOrss  zPoly.terms_gcdcCs.t|jdr|j|}n t|d||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)rr;rr"r~)r{r_rrNrNrOrs  zPoly.add_groundcCs.t|jdr|j|}n t|d||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)rr;rr"r~)r{r_rrNrNrOrs  zPoly.sub_groundcCs.t|jdr|j|}n t|d||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)rr;rr"r~)r{r_rrNrNrOrs  zPoly.mul_groundcCs.t|jdr|j|}n t|d||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)rr;rr"r~)r{r_rrNrNrOrs  zPoly.quo_groundcCs.t|jdr|j|}n t|d||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)rr;rr"r~)r{r_rrNrNrOrs  zPoly.exquo_groundcCs,t|jdr|j}n t|d||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)rr;rr"r~)r{rrNrNrOrs   zPoly.abscCs,t|jdr|j}n t|d||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)rr;rr"r~)r{rrNrNrOrs   zPoly.negcCsTt|}|js||S||\}}}}t|jdrB||}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)rrHrrzrr;rr")r{r|r}r~rrrrNrNrOr&s    zPoly.addcCsTt|}|js||S||\}}}}t|jdrB||}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)rrHrrzrr;rr")r{r|r}r~rrrrNrNrOrEs    zPoly.subcCsTt|}|js||S||\}}}}t|jdrB||}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') mul)rrHrrzrr;rr")r{r|r}r~rrrrNrNrOrds    zPoly.mulcCs,t|jdr|j}n t|d||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)rr;rr"r~)r{rrNrNrOrs   zPoly.sqrcCs6t|}t|jdr"|j|}n t|d||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)rrr;rr"r~)r{rrrNrNrOrs   zPoly.powcCsH||\}}}}t|jdr.||\}}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)rzrr;rr")r{r|r}r~rrqrrNrNrOrs   z Poly.pdivcCs<||\}}}}t|jdr*||}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)rzrr;rr")r{r|r}r~rrrrNrNrOrs    z Poly.premcCs<||\}}}}t|jdr*||}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)rzrr;rr")r{r|r}r~rrrrNrNrOrs    z Poly.pquoc Csx||\}}}}t|jdrfy||}Wqptk rb}z|||Wdd}~XYqpXn t|d||S)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)rzrr;rr)rUrdr")r{r|r}r~rrrexcrNrNrOrs ( z Poly.pexquoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrX||\}} n t|d|ry|| } } Wnt k rYn X| | }} |||| fS)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) rzis_Ringis_Fieldrgrr;rr"rr$) r{r|autorqr~rrrrrQRrNrNrOr.s   zPoly.divc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|ry |}Wnt k rYnX||S)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) rzrrrgrr;rr"rr$) r{r|rrqr~rrrrrNrNrOrUs    zPoly.remc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|ry |}Wnt k rYnX||S)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) rzrrrgrr;rr"rr$) r{r|rrqr~rrrrrNrNrOrzs    zPoly.quoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdry||}Wqtk r} z| | | Wdd} ~ XYqXn t |d|ry | }Wnt k rYnX||S)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) rzrrrgrr;rr)rUrdr"rr$) r{r|rrqr~rrrrrrNrNrOrs" (  z Poly.exquocCst|trXt|j}| |kr*|krDnn|dkr>||S|Sqtd|||fn2y|jt|Stk rtd|YnXdS)z3Returns level associated with the given generator. rz -%s <= gen < %s expected, got %sz"a valid generator expected, got %sN)rCrrSr<r'rrr)r{rurrNrNrOrs  zPoly._gen_to_levelrcCs0||}t|jdr"|j|St|ddS)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 degreeN)rrr;rr")r{rurrNrNrOrs   z Poly.degreecCs$t|jdr|jSt|ddS)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_listN)rr;rr")r{rNrNrOrs  zPoly.degree_listcCs$t|jdr|jSt|ddS)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_degreeN)rr;rr")r{rNrNrOr s  zPoly.total_degreecCs~t|tstdt|||jkr8|j|}|j}nt|j}|j|f}t|jdrp|j |j ||dSt |ddS)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 homogenize)r<homogeneous_orderN) rCr TypeErrortyper<rrSrr;r~rr")r{srpr<rNrNrOr s      zPoly.homogenizecCs$t|jdr|jSt|ddS)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 rN)rr;rr")r{rNrNrOrBs  zPoly.homogeneous_ordercCsF|dk r||dSt|jdr.|j}n t|d|jj|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 NrLC)rtrr;rr"rqr)r{r=rrNrNrOr[s    zPoly.LCcCs0t|jdr|j}n t|d|jj|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)rr;rr"rqr)r{rrNrNrOrss   zPoly.TCcCs(t|jdr||dSt|ddS)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 rtECN)rr;rtr")r{r=rNrNrOrs zPoly.ECcCs|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 r< exponents)r{r^rNrNrOcoeff_monomials#zPoly.coeff_monomialcGsVt|jdr>t|t|jkr&td|jjttt|}n t |d|jj |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) rr;rSr<rrrGr`rr"rqr)r{NrrNrNrOrs   zPoly.nthrQcCs tddS)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.)rA)r{rrrightrNrNrOr_sz Poly.coeffcCst||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 r)r rlr<)r{r=rNrNrOLMszPoly.LMcCst||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 r)r rlr<)r{r=rNrNrOEMszPoly.EMcCs"||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) r)rr r<)r{r=r^r_rNrNrOLTszPoly.LTcCs"||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) r)rr r<)r{r=r^r_rNrNrOET'szPoly.ETcCs0t|jdr|j}n t|d|jj|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)rr;rr"rqr)r{rrNrNrOr8s   z Poly.max_normcCs0t|jdr|j}n t|d|jj|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)rr;rr"rqr)r{rrNrNrOrMs   z Poly.l1_normcCs|}|jjjstj|fS|}|jr2|jj}t|jdrN|j \}}n t |d| || |}}|rx|js||fS|| fSdS)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_denomsN)r;rqrrOnervhas_assoc_Ringget_ringrrr"rr~r)rhr\r{rqr_rrNrNrOrbs      zPoly.clear_denomscCsv|}||\}}}}||}||}|jr2|js:||fS|jdd\}}|jdd\}}||}||}||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]') T)r\)rzrrrr)rhr|r{rqr~abrNrNrOrat_clear_denomss   zPoly.rat_clear_denomscOs|}|ddr"|jjjr"|}t|jdr|sF||jjddS|j}xB|D]:}t|t krl|\}}n |d}}|t || |}qRW||St |ddS)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 integraterQ)rN) getr;rqrrgrr~rrrrrr")rhspecsrLr{r;specrurrNrNrOrs      zPoly.integratecOs|ddst|f||St|jdr|s@||jjddS|j}xB|D]:}t|tkrf|\}}n |d}}|t|| |}qLW||St |ddS)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') ZevaluateTdiffrQ)rN) rrrr;r~rrrrrr")r{rkwargsr;rrurrNrNrOrs       z Poly.diffc Cs\|}|dkrt|tr@|}x |D]\}}|||}q$W|St|ttfr|}t|t|jkrltdx$t |j|D]\}}|||}qzW|Sd|} }n | |} t |j dst |dy|j || } Wnxtk rL|std||j jfnFt|g\} \}|| |j} || }| || }|j || } YnX|j| | dS)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') Nztoo many values providedrrzcan't evaluate at %s in %s)r)rCrDr[rrrGrSr<rrrrr;r"r$r#rqr5rvZunify_with_symbolsrfr\r~) rhrrrr{rrurvaluesrrZa_domainZ new_domainrNrNrOr s:       z Poly.evalcGs ||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{rrNrNrO__call__L sz Poly.__call__c Csd||\}}}}|r.|jr.||}}t|jdrJ||\}}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)rzrrgrr;rr") r{r|rrqr~rrrhrNrNrOrb s   zPoly.half_gcdexc Csl||\}}}}|r.|jr.||}}t|jdrL||\}}} 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)rzrrgrr;rr") r{r|rrqr~rrrtrrNrNrOr s   z Poly.gcdexcCsX||\}}}}|r.|jr.||}}t|jdrF||}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)rzrrgrr;rr")r{r|rrqr~rrrrNrNrOr s    z Poly.invertcCs2t|jdr|jt|}n t|d||S)ac 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 - 1, x).revert(1) Traceback (most recent call last): ... NotReversible: only unity is 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)rr;r rr"r~)r{rrrNrNrOr  s  z Poly.revertcCsB||\}}}}t|jdr*||}n t|dtt||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)rzrr;r r"rGr`)r{r|r}r~rrrrNrNrOr  s    zPoly.subresultantsc Csv||\}}}}t|jdrB|r6|j||d\}}qL||}n t|d|rj||ddtt||fS||ddS)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) includePRSr)r)rzrr;r r"rGr`) r{r|r r}r~rrrrrNrNrOr  s   zPoly.resultantcCs0t|jdr|j}n t|d|j|ddS)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 discriminantr)r)rr;r r"r~)r{rrNrNrOr ! s   zPoly.discriminantcCsddlm}|||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|rrNrNrOr6 sH zPoly.dispersionsetcCsddlm}|||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|rrNrNrOr sH zPoly.dispersionc CsP||\}}}}t|jdr0||\}}}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)rzrr;rr") r{r|r}r~rrrcffcfgrNrNrOr s   zPoly.cofactorscCs<||\}}}}t|jdr*||}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)rzrr;rr")r{r|r}r~rrrrNrNrOr s    zPoly.gcdcCs<||\}}}}t|jdr*||}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)rzrr;rr")r{r|r}r~rrrrNrNrOr s    zPoly.lcmcCs<|jj|}t|jdr(|j|}n t|d||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)r;rqr\rrr"r~)r{prrNrNrOr s   z Poly.trunccCsF|}|r|jjjr|}t|jdr2|j}n t|d||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)r;rqrrgrrr"r~)rhrr{rrNrNrOr. s   z Poly.moniccCs0t|jdr|j}n t|d|jj|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)rr;rr"rqr)r{rrNrNrOrK s   z Poly.contentcCs>t|jdr|j\}}n t|d|jj|||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)rr;rr"rqrr~)r{contrrNrNrOr` s  zPoly.primitivecCs<||\}}}}t|jdr*||}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)rzrr;rr")r{r|r}r~rrrrNrNrOru s    z Poly.composecCs2t|jdr|j}n t|dtt|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)rr;rr"rGr`r~)r{rrNrNrOr s   zPoly.decomposecCs.t|jdr|j|}n t|d||S)a 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') shift)rr;rr"r~)r{rrrNrNrOr s  z Poly.shiftcCs^||\}}||\}}||\}}t|jdrJ|j|j|j}n t|d||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)rrr;rr"r~)r{rrPrrrrNrNrOr s  zPoly.transformcCsL|}|r|jjjr|}t|jdr2|j}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) r;rqrrgrr!r"rGr`r~)rhrr{rrNrNrOr! s   z Poly.sturmcs4tjdrj}n tdfdd|DS)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_listcsg|]\}}||fqSrN)r~)rr|r)r{rNrOr sz!Poly.gff_list..)rr;r"r")r{rrN)r{rOr" s   z Poly.gff_listcCs,t|jdr|j}n t|d||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)rr;r#r"r~)r{rrNrNrOr# s   z Poly.normcCs>t|jdr|j\}}}n t|d|||||fS)af 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)rr;r$r"r~)r{rr|rrNrNrOr$' s  z Poly.sqf_normcCs,t|jdr|j}n t|d||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)rr;r%r"r~)r{rrNrNrOr%F s   z Poly.sqf_partcsHtjdrj|\}}n tdjj|fdd|DfS)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_listcsg|]\}}||fqSrN)r~)rr|r)r{rNrOrv sz!Poly.sqf_list..)rr;r&r"rqr)r{allr_factorsrN)r{rOr&[ s  z Poly.sqf_listcs6tjdrj|}n tdfdd|DS)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_includecsg|]\}}||fqSrN)r~)rr|r)r{rNrOr sz)Poly.sqf_list_include..)rr;r)r")r{r'r(rN)r{rOr)x s  zPoly.sqf_list_includecsltjdrByj\}}WqLtk r>tjdfgfSXn tdjj|fdd|DfS)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_listrQcsg|]\}}||fqSrN)r~)rr|r)r{rNrOr sz$Poly.factor_list..) rr;r*r#rrr"rqr)r{r_r(rN)r{rOr* s  zPoly.factor_listcsTtjdr8yj}WqBtk r4dfgSXn tdfdd|DS)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_includerQcsg|]\}}||fqSrN)r~)rr|r)r{rNrOr sz,Poly.factor_list_include..)rr;r+r#r")r{r(rN)r{rOr+ s  zPoly.factor_list_includec Cs |dk r"t|}|dkr"td|dk r4t|}|dk rFt|}t|jdrl|jj||||||d}n t|d|rdd}|stt||Sdd } |\} } tt|| tt| | fSd d}|stt||Sd d } |\} } tt|| tt| | fSdS) 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)] Nrz!'eps' must be a positive rational intervals)r'epsinfsupfastsqfcSs|\}}t|t|fS)N)r3r)intervalrrrNrNrO_real szPoly.intervals.._realcSs@|\\}}\}}t|tt|t|tt|fS)N)r3rr) rectangleuvrrrNrNrO_complex sz Poly.intervals.._complexcSs$|\\}}}t|t|f|fS)N)r3r)r2rrrrNrNrOr3 s cSsH|\\\}}\}}}t|tt|t|tt|f|fS)N)r3rr)r4r5r6rrrrNrNrOr7 s) r3r\rrr;r,r"rGr`) r{r'r-r.r/r0r1rr3r7Z real_partZ complex_partrNrNrOr, s2     zPoly.intervalsc Cs|r|jstdt|t|}}|dk rJt|}|dkrJtd|dk r\t|}n |dkrhd}t|jdr|jj|||||d\}}n t |dt |t |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 supportedNrz!'eps' must be a positive rationalrQ refine_root)r-stepsr0) is_sqfr'r3r\rrrr;r8r"r) r{rrr-r9r0 check_sqfrTrNrNrOr8 s     zPoly.refine_rootcCsLd\}}|dk r^t|}|tjkr(d}n6|\}}|sDt|}ntttj||fd}}|dk rt|}|tjkr~d}n6|\}}|st|}ntttj||fd}}|r|rt |j dr|j j ||d}n t |dn^|r|dk r|tj f}|r|dk r|tj f}t |j dr:|j j||d}n t |dt|S)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_roots)r.r/count_complex_roots)rrNegativeInfinity as_real_imagr3r\rGr`ZInfinityrr;r=r"rwr>r)r{r.r/Zinf_realZsup_realreZimcountrNrNrO count_roots@ s:           zPoly.count_rootscCstjjj|||dS)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 rootoftoolsZrootof)r{rrDrNrNrOroot sz Poly.rootcCs,tjjjj||d}|r|St|ddSdS)aL Return a list of real roots with multiplicities. 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)] )rDF)multipleN)rErFrGCRootOf real_rootsr-)r{rIrDZrealsrNrNrOrK szPoly.real_rootscCs,tjjjj||d}|r|St|ddSdS)a Return a list of real and complex roots with multiplicities. 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)] )rDF)rIN)rErFrGrJ all_rootsr-)r{rIrDrootsrNrNrOrL szPoly.all_roots2c spddlm|jrtd||dkr.gS|jjtkrNdd|D}n|jjt krdd|D}ddl m }||fdd|D}nNfd d|D}yd d|D}Wn$t k rt d |jjYnXtjj}tj_zjy>tj|||d |d d}tttt|fddd}Wn&tk r\td|fYnXWd|tj_X|S)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] r)signz#can't compute numerical roots of %scSsg|] }t|qSrN)r)rr_rNrNrOr szPoly.nroots..cSsg|] }|jqSrN)r)rr_rNrNrOr s)ilcmcsg|]}t|qSrN)r)rr_)facrNrOr scsg|]}|jdqS))r)Zevalfr@)rr_)rrNrOr scSsg|]}tj|qSrN)mpmathZmpc)rr_rNrNrOr sz!Numerical domain expected, got %sF )maxstepscleanuperrorZ extrapreccs$|jr dnd|jt|j|jfS)NrQr)imagrealr)r)rPrNrO szPoly.nroots..)keyz7convergence to root failed; try n < %s or maxsteps > %sN)Z$sympy.functions.elementary.complexesrPis_multivariater(rr;rqr4rr3Zsympy.core.numbersrQrr#rSZmpdpsZ polyrootsrGr`rsortedr1) r{rrUrVrtZdenomsrQr]rMrN)rRrrPrOnroots sB         z Poly.nrootscCsT|jrtd|i}x8|dD](\}}|jr$|\}}||| |<q$W|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 can't compute ground roots of %srQ)r\r(r* is_linearr)r{rMfactorrrrrNrNrO ground_rootss  zPoly.ground_rootscCsr|jrtdt|}|jr.|dkr.t|}n td||j}td}||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 polynomialrQz&'n' must an integer and n >= 1, got %sr) r\r(r is_Integerrrrur r rarYr)r{rrrrrrNrNrOnth_power_roots_poly1s  zPoly.nth_power_roots_polyc Cs||\}}}}t|dr,|j||d}n t|d|s~|jrH|}|\}} } } ||}|| } || || || fStt||SdS)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)includeN) rzrrer"rrrrr`) r{r|rfrqr~rrrcpcqrrrNrNrOreYs     z Poly.cancelcCs|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 )r;is_zero)r{rNrNrOri~sz Poly.is_zerocCs|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 )r;is_one)r{rNrNrOrjsz Poly.is_onecCs|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 )r;r:)r{rNrNrOr:sz Poly.is_sqfcCs|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 )r;is_monic)r{rNrNrOrksz Poly.is_moniccCs|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 )r; is_primitive)r{rNrNrOrlszPoly.is_primitivecCs|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 )r; is_ground)r{rNrNrOrmszPoly.is_groundcCs|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 )r;r`)r{rNrNrOr`szPoly.is_linearcCs|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 )r; is_quadratic)r{rNrNrOrnszPoly.is_quadraticcCs|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 )r; is_monomial)r{rNrNrOroszPoly.is_monomialcCs|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 )r;is_homogeneous)r{rNrNrOrp+szPoly.is_homogeneouscCs|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 )r;is_irreducible)r{rNrNrOrqCszPoly.is_irreduciblecCst|jdkS)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 rQ)rSr<)r{rNrNrOrVszPoly.is_univariatecCst|jdkS)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 rQ)rSr<)r{rNrNrOr\mszPoly.is_multivariatecCs|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 )r; is_cyclotomic)r{rNrNrOrrszPoly.is_cyclotomiccCs|S)N)r)r{rNrNrO__abs__sz Poly.__abs__cCs|S)N)r)r{rNrNrO__neg__sz Poly.__neg__r|cCsD|js:y|j|f|j}Wntk r8||SX||S)N)rHrar<r'rdr)r{r|rNrNrO__add__s z Poly.__add__cCsD|js:y|j|f|j}Wntk r8||SX||S)N)rHrar<r'rdr)r{r|rNrNrO__radd__s z Poly.__radd__cCsD|js:y|j|f|j}Wntk r8||SX||S)N)rHrar<r'rdr)r{r|rNrNrO__sub__s z Poly.__sub__cCsD|js:y|j|f|j}Wntk r8||SX||S)N)rHrar<r'rdr)r{r|rNrNrO__rsub__s z Poly.__rsub__cCsD|js:y|j|f|j}Wntk r8||SX||S)N)rHrar<r'rdr)r{r|rNrNrO__mul__s z Poly.__mul__cCsD|js:y|j|f|j}Wntk r8||SX||S)N)rHrar<r'rdr)r{r|rNrNrO__rmul__s z Poly.__rmul__rcCs(|jr|dkr||S||SdS)Nr)rcrrd)r{rrNrNrO__pow__s z Poly.__pow__cCs"|js|j|f|j}||S)N)rHrar<r)r{r|rNrNrO __divmod__szPoly.__divmod__cCs"|js|j|f|j}||S)N)rHrar<r)r{r|rNrNrO __rdivmod__szPoly.__rdivmod__cCs"|js|j|f|j}||S)N)rHrar<r)r{r|rNrNrO__mod__sz Poly.__mod__cCs"|js|j|f|j}||S)N)rHrar<r)r{r|rNrNrO__rmod__sz Poly.__rmod__cCs"|js|j|f|j}||S)N)rHrar<r)r{r|rNrNrO __floordiv__szPoly.__floordiv__cCs"|js|j|f|j}||S)N)rHrar<r)r{r|rNrNrO __rfloordiv__szPoly.__rfloordiv__cCs||S)N)rd)r{r|rNrNrO__div__sz Poly.__div__cCs||S)N)rd)r{r|rNrNrO__rdiv__sz Poly.__rdiv__otherc Cs||}}|jsFy|j||j|d}Wntttfk rDdSX|j|jkrVdS|jj|jjkry|jj |jj|j}Wnt k rdSX| |}| |}|j|jkS)N)rZF) rHrar<rvr'r#r$r;rqrr%rf)rhrr{r|rqrNrNrO__eq__s     z Poly.__eq__cCs ||k S)NrN)r{r|rNrNrO__ne__2sz Poly.__ne__cCs|j S)N)ri)r{rNrNrO __nonzero__6szPoly.__nonzero__cCs|s ||kS|t|SdS)N) _strict_eqr)r{r|strictrNrNrOeq;szPoly.eqcCs|j||d S)N)r)r)r{r|rrNrNrOneAszPoly.necCs*t||jo(|j|jko(|jj|jddS)NT)r)rCrar<r;r)r{r|rNrNrOrDszPoly._strict_eq)NN)N)N)N)N)N)N)FF)F)F)T)T)T)T)r)N)N)rQF)N)N)N)N)F)NT)T)T)T)F)N)N)T)T)F)F)FNNNFF)NNFF)NN)T)TT)TT)rNrOT)F)F)F)__name__ __module__ __qualname____doc__ __slots__is_commutativerHZ _op_priorityrP classmethodrUrVrWrXrYrErFrIrJrirkpropertyrmrnrLrurZrwrxryrrzr~rfrvrrrr>rrerrrrgrrrrtrlrrrrrrrrrdrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr_rrrrrrrrrrZ_eval_derivativeZ _eval_diffrrrrrr r r r rrrrrrrrrrrrrr!r"r#r$r%r&r)r*r+r,r8rCrHrKrLr_rbrdrerirjr:rkrlrmr`rnrorprqrr\rrrsrtrNotImplementedrurvrwrxryrzr{r|r}r~rrrrr __truediv__ __rtruediv__rrr__bool__rrr __classcell__rNrN)rarOr:=sp*                  3   "$"     %  % %*' ' % % * "  %"     ''(& K  ! " % K K  #!  L%?J  (%         r:csVeZdZdZddZfddZeddZede d d Z d d Z d dZ Z S)PurePolyz)Class for representing pure polynomials. cCs|jfS)z$Allow SymPy to hash Poly instances. )r;)rhrNrNrOriLszPurePoly._hashable_contentcstt|S)N)rjrrk)rh)rarNrOrkPszPurePoly.__hash__cCs|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} )rn)rhrNrNrOrmSszPurePoly.free_symbolsrc Cs||}}|jsFy|j||j|d}Wntttfk rDdSXt|jt|jkr^dS|jj |jj kry|jj |jj |j}Wnt k rdSX| |}| |}|j|jkS)N)rZF) rHrar<rvr'r#r$rSr;rqrr%rf)rhrr{r|rqrNrNrOrhs    zPurePoly.__eq__cCst||jo|jj|jddS)NT)r)rCrar;r)r{r|rNrNrOrszPurePoly._strict_eqcst|}|jsZy&|jj|j|j|j|jj|fStk rXtd||fYnXt|j t|j kr~td||ft |jt rt |jt std||f|j |j }|jj |jj|}|j|}|j|}||dffdd }||||fS)Nzcan't unify %s with %scsB|dk r2|d|||dd}|s2||Sj|f|S)NrQ)rrU)r;rqr<r)rKrNrOr~s  zPurePoly._unify..per)rrHr;rqr~rr$r%rSr<rCrrarr\)r{r|r<rqrrr~rN)rKrOrzs"&   zPurePoly._unify)rrrrrirkrrmrrrrrzrrNrN)rarOrHs  rcOst||}t||S)z+Construct a polynomial from an expression. )r?r@_poly_from_expr)exprr<rLrMrNrNrOpoly_from_exprs rcCs|t|}}t|ts&t|||nJ|jrb|j||}|j|_|j|_|j dkrZd|_ ||fS|j rp| }t ||\}}|jst|||t t t |\}}|j}|dkrt||d\|_}nt t|j|}tt t ||}t||}|j dkr d|_ ||fS)z+Construct a polynomial from an expression. NT)rMF)rrCrr*rHrarIr<rZrFexpandrrGrr[r5r`rrDr:rE)rrMorigpolyr;rlrtrZrNrNrOrs2     rcOst||}t||S)z(Construct polynomials from expressions. )r?r@_parallel_poly_from_expr)exprsr<rLrMrNrNrOparallel_poly_from_exprs rcCsddlm}t|dkr|\}}t|trt|tr|j||}|j||}||\}}|j|_|j |_ |j dkr~d|_ ||g|fSt |g}}gg}}d}x`t |D]T\} } t | } t| tr| jr|| q|| |jr| } nd}|| qW|rt|||d|rBx|D]} || || <q(Wt||\} }|jsft|||dx$|jD]} t| |rntdqnWgg} }g}g}xH| D]@}t tt |\}}| ||||t|qW|j }|dkr t| |d\|_ } nt t|j| } x,|D]$} || d| | | d} q"Wg}x@t||D]2\}}tt t||}t||}||qZW|j dkrt||_ ||fS) z(Construct polynomials from expressions. r) PiecewiseNTFz&Piecewise generators do not make sense)rM)$sympy.functions.elementary.piecewiserrSrCr:rarIrr<rZrFrGrrrrHrrr*rdrr'rr[extendr5r`rrDrEbool)rrMrr{r|ZorigsZ_exprsZ_polysZfailedrprrepsrZ coeffs_listZlengthsrrr;rlrtrZrFrrNrNrOrsv                     rcCst|}||kr|||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )rD)rLr[rrNrNrO _update_args;srcCst|dd}|jr"|}|j}n|j}|s8t|\}}|rL|rFtjStjSt|ddjs|jrz||jkrzt|\}}||jkrtjSn4|jst |j dkrt t d|t t|j |ft||S)ax 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 ======== total_degree degree_list T)rrQz A symbolic generator of interest is required for a multivariate expression like func = %s, e.g. degree(func, gen = %s) instead of degree(func, gen = %s). )rrHrd is_NumberrrZeror?r<rSrmrr0nextr9rr)r{rurZisNumr}rNrNrOrEs$    rcGsHt|}|jr|}|jr"d}n|jr2|p0|j}t||}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, z >>> 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)rrHrdrr<r:rr)r{r<rrvrNrNrOr{s( rc Oslt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}ttt|S)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) rFrrQN) r? allowed_flagsrr*r+rrr`r)r{r<rLrrMrZdegreesrNrNrOrsrc Osdt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|j|jdS)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 rFrrQN)r=)r?rrr*r+rr=)r{r<rLrrMrrNrNrOrs rc Oslt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|j|jd}|S)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 rFrrQN)r=)r?rrr*r+rr=rd)r{r<rLrrMrr^rNrNrOrsrc Ostt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|j|jd\}}||S)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 rFrrQN)r=)r?rrr*r+rr=rd)r{r<rLrrMrr^r_rNrNrOrsrc Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||\}} |js|| fS|| fSdS)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) rFrrN)r?rrr*r+rrFrd) r{r|r<rLrrrMrrrrNrNrOrs rc Os~t|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|jsv|S|SdS)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 rFrrN)r?rrr*r+rrFrd) r{r|r<rLrrrMrrrNrNrOr6s  rc Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnXy||}Wntk rt||YnX|js|S|SdS)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 rFrrN) r?rrr*r+rr)rFrd) r{r|r<rLrrrMrrrNrNrOrTs rc Os~t|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|jsv|S|SdS)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 rFrrN)r?rrr*r+rrFrd) r{r|r<rLrrrMrrrNrNrOrws  rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd\}} |js|| fS|| fSdS)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) rrFrrN)r) r?rrr*r+rrrFrd) r{r|r<rLrrrMrrrrNrNrOrs rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd}|js~|S|SdS)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 rrFrrN)r) r?rrr*r+rrrFrd) r{r|r<rLrrrMrrrNrNrOrs rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd}|js~|S|SdS)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 rrFrrN)r) r?rrr*r+rrrFrd) r{r|r<rLrrrMrrrNrNrOrs rc Ost|ddgy t||ff||\\}}}Wn.tk r^}ztdd|Wdd}~XYnX|j||jd}|js~|S|SdS)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 rrFrrN)r) r?rrr*r+rrrFrd) r{r|r<rLrrrMrrrNrNrOrs rc Ost|ddgy t||ff||\\}}}Wn~tk r}z`t|j\}\} } y|| | \} } Wn tk rtdd|YnX| | | | fSWdd}~XYnX|j||j d\} } |j s| | fS| | fSdS)aU 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) (-x/5 + 3/5, x + 1) rrFrrN)r) r?rrr*r5rrrAr+rrrFrd) r{r|r<rLrrrMrrZrrrrrNrNrOrs &rc Ost|ddgy t||ff||\\}}}Wntk r}zjt|j\}\} } y|| | \} } } Wn tk rtdd|YnX| | | | | | fSWdd}~XYnX|j||j d\} } } |j s| | | fS| | | fSdS)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 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) (-x/5 + 3/5, x**2/5 - 6*x/5 + 2, x + 1) rrFrrN)r) r?rrr*r5rrrAr+rrrFrd)r{r|r<rLrrrMrrZrrrrrrNrNrOrDs .rc Ost|ddgy t||ff||\\}}}Wnhtk r}zJt|j\}\} } y||| | Stk rt dd|YnXWdd}~XYnX|j||j d} |j s| S| SdS)a> Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S >>> from sympy.core.numbers import 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 ``mod_inverse`` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.numbers.mod_inverse rrFrrN)r) r?rrr*r5rrrrAr+rrFrd) r{r|r<rLrrrMrrZrrrrNrNrOrks  $rc Ost|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|js|dd|DS|SdS)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] rFr rNcSsg|] }|qSrN)rd)rrrNrNrOrsz!subresultants..)r?rrr*r+r rF) r{r|r<rLrrrMrrrNrNrOr s  r c Os|dd}t|dgy t||ff||\\}}}Wn.tk rh}ztdd|Wdd}~XYnX|r|j||d\} } n ||} |js|r| dd | DfS| S|r| | fS| SdS) 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 r FrFr rN)r cSsg|] }|qSrN)rd)rrrNrNrOrszresultant..) popr?rrr*r+r rFrd) r{r|r<rLr rrrMrrrrNrNrOr s    r c Ostt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsl|S|SdS)z Compute discriminant of ``f``. Examples ======== >>> from sympy import discriminant >>> from sympy.abc import x >>> discriminant(x**2 + 2*x + 3) -8 rFr rQN)r?rrr*r+r rFrd)r{r<rLrrMrrrNrNrOr sr c Ost|dgy t||ff||\\}}}Wntk r}zjt|j\}\} } y|| | \} } } Wn tk rtdd|YnX| | | | | | fSWdd}~XYnX||\} } } |j s| | | fS| | | fSdS)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) rFrrN) r?rrr*r5rrrAr+rrFrd)r{r|r<rLrrrMrrZrrrrrrNrNrOrs .rc st|}fdd}||}|dk r*|Stdgyt|f\}}t|dkrtdd|Dr|dfd d |ddD}td d|Drd}x|D]} t|| d }qW|SWnJtk r} z*|| j }|dk r|St d t|| Wdd} ~ XYnX|s:|j s.t j Std |dS|d |dd}}x"|D]} || }|jrVPqVW|j s|S|SdS)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 csnsjsjt|\}}|s|jS|jrj|d|dd}}x$|D]}|||}||r@Pq@W||SdS)NrrQ)r5rwrrrjr)seqrZnumbersrnumber)rLr<rNrOtry_non_polynomial_gcd;s     z(gcd_list..try_non_polynomial_gcdNrFrQcss|]}|jo|jVqdS)N) is_algebraic is_irrational)rrrNrNrOrYszgcd_list..rcsg|]}|qSrN)ratsimp)rr)rrNrOr[szgcd_list..css|] }|jVqdS)N) is_rational)rfrcrNrNrOr\srgcd_list)rM)rr?rrrSr'ras_numer_denomr*rr+rFrrr:rrjrd) rr<rLrrrFrMlstlcrrrrN)rrLr<rOr*sB   "   rc OsFt|dr,|dk r|f|}t|f||S|dkr| S| SdS)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 argumentsrFrrr)rrrr?rrr`rrrrrrr*r5rrrrAr+rFrd) r{r|r<rLrrrMrrrrrZrrNrNrOr~s0   $ rc st|}fdd}||}|dk r*|Stdgyt|f\}}t|dkrtdd|Dr|dfd d |ddD}td d|Drd}x|D]} t|| d}qW|SWnJtk r} z*|| j }|dk r|St d t|| Wdd} ~ XYnX|s:|j s.t j Std|d S|d|dd}}x|D]} || }qVW|j sz|S|SdS)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 csbs^s^t|\}}|s|jS|jr^|d|dd}}x|D]}|||}q@W||SdS)NrrQ)r5rxrrr)rrZrrr)rLr<rNrOtry_non_polynomial_lcms   z(lcm_list..try_non_polynomial_lcmNrFrQcss|]}|jo|jVqdS)N)rr)rrrNrNrOrszlcm_list..rcsg|]}|qSrN)r)rr)rrNrOrszlcm_list..css|] }|jVqdS)N)r)rrrNrNrOrslcm_list)rMr)rr?rrrSr'rrr*rr+rFrrr:rd) rr<rLrrrFrMrrrrrrN)rrLr<rOrs>   "  rc OsFt|dr,|dk r|f|}t|f||S|dkr| S| SdS)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 argumentsrFrQrr)rrrr?rrr`rrrrrrr*r5rrrrAr+rFrd) r{r|r<rLrrrMrrrrrZrrNrNrOrs0   $ rc sddlm}t|}t|tr$|jr(|Sddrr|jfdd|jD} ddd<t |fSt||r|S dd }t d gyt |f\}}Wn$tk r} z| jSd } ~ XYnX| \} }|jjr(|jjr|jd d \} }|\} }|jjr.| | } ntj} td dt|j| D} | dkrftj} | dkrf|S|r~t| | |St| |dd\} }t| | |ddS)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 r)EqualitydeepFcsg|]}t|fqSrN)r)rr)rLr<rNrOr{szterms_gcd..rclearTrFN)r\cSsg|]\}}||qSrNrN)rrrrNrNrOrsrQ)r)sympy.core.relationalrrrCris_AtomrrrLrrr?rrr*rrZrrrrrrr rr<r rdZ as_coeff_Mul)r{r<rLrrrUrrrMrrdenomr_termrN)rLr<rOr2sDB             rc Os|t|ddgyt|f||\}}Wn.tk rV}ztdd|Wdd}~XYnX|t|}|jst|S|SdS)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 rrFrrQN) r?rrr*r+rrrFrd)r{rr<rLrrMrrrNrNrOrsrc Os|t|ddgyt|f||\}}Wn.tk rV}ztdd|Wdd}~XYnX|j|jd}|jst|S|SdS)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 rrFrrQN)r) r?rrr*r+rrrFrd)r{r<rLrrMrrrNrNrOrsrc Os^t|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|S)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 rFrrQN)r?rrr*r+r)r{r<rLrrMrrNrNrOrs rc Ost|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|\}}|jst||fS||fSdS)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) rFrrQN)r?rrr*r+rrFrd)r{r<rLrrMrrrrNrNrOrs   rc Os~t|dgy t||ff||\\}}}Wn.tk r\}ztdd|Wdd}~XYnX||}|jsv|S|SdS)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 rFrrN)r?rrr*r+rrFrd) r{r|r<rLrrrMrrrNrNrOr)s  rc Oszt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsrdd|DS|SdS)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] rFrrQNcSsg|] }|qSrN)rd)rrrNrNrOr`szdecompose..)r?rrr*r+rrF)r{r<rLrrMrrrNrNrOrGsrc Ost|ddgyt|f||\}}Wn.tk rV}ztdd|Wdd}~XYnX|j|jd}|jszdd|DS|SdS) 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] rrFr!rQN)rcSsg|] }|qSrN)rd)rrrNrNrOr~szsturm..)r?rrr*r+r!rrF)r{r<rLrrMrrrNrNrOr!esr!c Oszt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsrdd|DS|SdS)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)).expand() == 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 rFr"rQNcSsg|]\}}||fqSrN)rd)rr|rrNrNrOrszgff_list..)r?rrr*r+r"rF)r{r<rLrrMrr(rNrNrOr"s r"cOs tddS)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialN)rA)r{r<rLrNrNrOgffsrc Ost|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|\}}}|jst|||fSt|||fSdS)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) rFr$rQN) r?rrr*r+r$rFrrd) r{r<rLrrMrrr|rrNrNrOr$sr$c Ostt|dgyt|f||\}}Wn.tk rT}ztdd|Wdd}~XYnX|}|jsl|S|SdS)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 rFr%rQN)r?rrr*r+r%rFrd)r{r<rLrrMrrrNrNrOr%sr%cCs&|dkrdd}ndd}t||dS)z&Sort a list of ``(expr, exp)`` pairs. r1cSs&|\}}|jj}|t|t|j|fS)N)r;rSr<)rTrexpr;rNrNrOr[sz_sorted_factors..keycSs&|\}}|jj}t|t|j||fS)N)r;rSr<)rTrrr;rNrNrOr[s)r[)r^)r(methodr[rNrNrO_sorted_factorss rcCstdd|DS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|]\}}||qSrN)rd)rr{rrNrNrOr sz$_factors_product..)r )r(rNrNrO_factors_productsrc stjg}}ddt|D}x|D]}|jr>||9}q(|jrR||jq(|jr|j\}|jrxjrx||9}q(|jr| |fq(n |tj}yt ||\}} Wn2t k r} z| | j fWdd} ~ XYq(Xt ||d} | \} } | tjk rDjr|| 9}n(| jr4| | fn| | tjftjkr\|| q(jr~|fdd| Dq(g}x@| D]8\}}|jr| ||fn| ||fqW| t|fq(W||fS)z.Helper function for :func:`_symbolic_factor`. cSs"g|]}t|dr|n|qS) _eval_factor)rr)rrprNrNrOrsz)_symbolic_factor_list..NZ_listcsg|]\}}||fqSrNrN)rr{r)rrNrOr8s)rrr make_argsris_MulrrLis_Powrrr*rgetattrrcZ is_positive is_integerrdr)rrMrr_r(rLargbaserr}rrZ_coeffZ_factorsrr{rrN)rrO_symbolic_factor_list sT     "     rcst|trD|jsDt|dr"|Stt|\}}t|t|St|drj|j fdd|j DSt|dr| fdd|DS|SdS)z%Helper function for :func:`_factor`. rrLcsg|]}t|qSrN)_symbolic_factor)rr)rrMrNrOrOsz$_symbolic_factor..rcsg|]}t|qSrN)r)rr)rrMrNrOrQsN) rCr is_Relationalrrrrr rrrLra)rrMrr_r(rN)rrMrOrGs   rcCsFt|ddgt||}t|}t|tr6|js6t|\}}t |||\}}t |||\} } | r~|j s~t d|| t dd} xJ|| fD]>} x8t| D],\} \}}|jst|| \}}||f| | <qWqWt||}t| |} |jsdd|D}dd| D} || }|j s*||fS||| fSn t d|d S) z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrFza polynomial expected, got %sT)rcSsg|]\}}||fqSrN)rd)rr{rrNrNrOrrsz(_generic_factor_list..cSsg|]\}}||fqSrN)rd)rr{rrNrNrOrssN)r?rr@rrCrrrrrrr'clonerDrrHrrrF)rr<rLrrMZnumerrrgfprhZfqZ_optr(rpr{rr}r_rNrNrO_generic_factor_listVs2      rcCs(t|gt||}tt|||S)z4Helper function for :func:`sqf` and :func:`factor`. )r?rr@rr)rr<rLrrMrNrNrO_generic_factors  rcsddlmd fdd }d fdd }dd }|jr||r|}|||}|rp|d|d d|d fS|||}|rdd|d|d fSdS)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*sqrt(2) + 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 r)simplifyNc sBddlm}t|jdkr&|jdjs.d|fS|}|}|pH|}|dd}fdd|D}|dr>|d|d}g}xt t|D].}||||d} | j sP| | qWd|} |jd} | |g} x4t d|dD]"}| ||d| ||qW|| }t |}|| |fSdS) 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``. r)r rQNcsg|] }|qSrNrN)rcoeffx)rrNrOrsz._try_rescale..r) sympy.core.addr rSr<rrrrrr8rrr:) r{f1r rrrtZ rescale1_xZcoeffs1rprZ rescale_xrr6)rrNrO _try_rescales2      " z(to_rational_coeffs.._try_rescalec sddlm}t|jdkr&|jdjs.d|fS|}|p@|}|dd}|d}|r|js|}|j r|j }|j }n|g}t |dddd\}} || |} | | } | | fSdS) 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``. r)r rQNcSs|jS)N)r)zrNrNrOrZsz._try_translate..T)binary)rr rSr<rrrrris_AddrLrr.r) r{rr rrtrrrLZc1Zc2Zalphaf2)rrNrO_try_translates$     z*to_rational_coeffs.._try_translatecSsddlm}|}d}xb|D]Z}xTt|D]F}||j}dd|D}|sTq.t|dkrdd}t|dkr.dSq.WqW|S)zS Return True if ``f`` is a sum with square roots but no other root r)FactorsFcSs,g|]$\}}|jr|jr|jdkr|jqS)r)rZ is_Rationalr)rrZwxrNrNrOrszAto_rational_coeffs.._has_square_roots..rT) sympy.core.exprtoolsrrtr rr(r[minmax)rrrtZhas_sqrrr{rrNrNrO_has_square_rootss      z-to_rational_coeffs.._has_square_rootsrQr)N)N)sympy.simplify.simplifyrrvrsr)r{rrrrrrN)rrOto_rational_coeffss& #  rc Cs ddlm}t||dd}|}t|}|s2dS|\}}}} t| } |r|| d|||} |d|} g} x| dddD],}| ||d||| i|dfqWnJ| d} g} x<| dddD](}| |d|||i|dfqW| | 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 r)rZEX)rZNrQ) rrr:rrr*rdrr)rrrZp1rZresrrrr|r(rZr1rrrNrNrO_torational_factor_list s&    .(rcOst|||ddS)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)]) r1)r)r)r{r<rLrNrNrOr&9sr&cOst|||ddS)z Compute square-free factorization of ``f``. Examples ======== >>> 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 r1)r)r)r{r<rLrNrNrOr1Ksr1cOst|||ddS)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)]) ra)r)r)r{r<rLrNrNrOr*]sr*c Ost|}|ddrhi}|tt}x8|D]0}t|f||}|jsJ|jr*||kr*|||<q*W||Syt |||ddSt k r}z&|j sddl m }||St |Wdd}~XYnXdS)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 >>> 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) See Also ======== sympy.ntheory.factor_.factorint rFra)rr) factor_ncN)rrZatomsr r rarrxreplacerr'rrr) r{r<rLZpartialsZmuladdrrRmsgrrNrNrOraos <      raFc Cs8t|dsBy t|}Wntk r*gSX|j||||||dSt|dd\}} t| jdkrdtx t|D]\} } | j j || <qnW|dk r| j |}|dkrt d|dk r| j |}|dk r| j |}t || j |||||d } g} x@| D]8\\}}}| j || j |}}| ||f|fqW| SdS) 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)] r)r'r-r.r/r0r1r3)rZrQNrz!'eps' must be a positive rational)r-r.r/rr0)rr:r&r,rrSr<r(rr;rZr\rrrr)rr'r-r.r/rr0r1rFrMrprr,rrrrrNrNrOr,s4     r,cCsDy t|}Wn tk r,td|YnX|j||||||dS)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) z+can't refine a root of %s, not a polynomial)r-r9r0r;)r:r&r'r8)r{rrr-r9r0r;rrNrNrOr8s  r8cCs@yt|dd}Wn tk r0td|YnX|j||dS)a Return the number of roots of ``f`` in ``[inf, sup]`` interval. If one of ``inf`` or ``sup`` is complex, it will return the number of roots in the complex rectangle with corners at ``inf`` and ``sup``. Examples ======== >>> 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 F)greedyz)can't count roots of %s, not a polynomial)r.r/)r:r&r'rC)r{r.r/rrNrNrOrCs rCTcCs>yt|dd}Wn tk r0td|YnX|j|dS)z Return a list of real roots with multiplicities of ``f``. Examples ======== >>> from sympy import real_roots >>> from sympy.abc import x >>> real_roots(2*x**3 - 7*x**2 + 4*x + 4) [-1/2, 2, 2] F)rz0can't compute real roots of %s, not a polynomial)rI)r:r&r'rK)r{rIrrNrNrOrK+s rKrNrOcCsByt|dd}Wn tk r0td|YnX|j|||dS)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] F)rz5can't compute numerical roots of %s, not a polynomial)rrUrV)r:r&r'r_)r{rrUrVrrNrNrOr_Cs r_c Os\t|gyt|f||\}}Wn.tk rR}ztdd|Wdd}~XYnX|S)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} rbrQN)r?rrr*r+rb)r{r<rLrrMrrNrNrOrb]s  rbc Ostt|gyt|f||\}}Wn.tk rR}ztdd|Wdd}~XYnX||}|jsl|S|SdS)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 rdrQN)r?rrr*r+rdrFrd)r{rr<rLrrMrrrNrNrOrdvs  rdc spddlm}ddlmt|dgt|}t|tt fst|j sVt|t sVt|t sZ|S||dd}| \}}n4t|dkr|\}}nt|t r||Std|y"t||ff||\\}}}WnHtk rt|tt fs|Stj||fSYntk r} z|jr.|s.t| |js>|jrt|jfd d dd \} } d d | D} |jt|j| f| Sg} t|} t| xZ| D]R}t|tt t frqy| !|t|f| "Wnt#k rYnXqW|$t%| SWdd} ~ XYnX||\} }}t|tt fsH| |&|&S|j'sb| |&|&fS| ||fSdS)ad Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol >>> 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 r) factor_terms)rrFT)Zradicalrzunexpected argument: %scs|jdko| S)NT)rhas)r)rrNrOrZszcancel..)rcSsg|] }t|qSrN)re)rrprNrNrOrszcancel..N)(rrrrr?rrrCrr rrrrrSrrr*rrr'rrrrr.rLrreZ _from_argsrrrrskiprArrDrdrF)r{r<rLrrrrrrMrrZncrZpoter rrN)rrOres\       "     rec st|ddgy"t|gt|f||\}Wn.tk r`}ztdd|Wdd}~XYnXj}d}jr|jr|j s t | dd}dd l m}|jjj\} } x4t|D](\} } | jj} | | || <qW|d|d d\} }fd d | D} tt |}|rnyd d | D|}}Wntk rbYn X||} }jsdd | D|fS| |fSdS)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) rFrreducedrNF)rZT)xringrQcsg|]}tt|qSrN)r:rErD)rr)rMrNrOrszreduced..cSsg|] }|qSrN)r)rrrNrNrOrscSsg|] }|qSrN)rd)rrrNrNrOr#s)r?rrrGr*r+rZrrrrrD get_fieldsympy.polys.ringsrr<r=rrfr;rrVrr:rErr$rFrd)r{rr<rLrFrrZrr_ringr}rprrr_Q_rrN)rMrOrs6"  rcOst|f||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 `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 ``method`` flag or with the :func:`setup` function from :mod:`sympy.polys.polyconfig`: >>> 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]_ ) GroebnerBasis)rr<rLrNrNrOr(s3rcOst|f||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 )ris_zero_dimensional)rr<rLrNrNrOr^src@seZdZdZddZeddZeddZedd Z ed d Z ed d Z eddZ eddZ ddZddZddZddZddZddZeddZd d!Zd(d#d$Zd%d&Zd'S))rz%Represents a reduced Groebner basis. c st|ddgyt|f||\}Wn2tk rZ}ztdt||Wdd}~XYnXddlm}|jj j fdd|D}t |j d }fd d|D}| |S) z>Compute a reduced Groebner basis for a system of polynomials. rFrrNr)PolyRingcs g|]}|r|jqSrN)rVr;r)rr)ringrNrOrsz)GroebnerBasis.__new__..)rcsg|]}t|qSrN)r:rE)rr|)rMrNrOrs)r?rrr*r+rSrrr<rZr= _groebnerr_new)rKrr<rLrFrrrrN)rMrrOrPts" zGroebnerBasis.__new__cCst|}t||_||_|S)N)rrPr_basis_options)rKbasisr?rTrNrNrOrs  zGroebnerBasis._newcCst|jt|jjfS)N)r rrr<)rhrNrNrOrLszGroebnerBasis.argscCsdd|jDS)NcSsg|] }|qSrN)rd)rrrNrNrOrsz'GroebnerBasis.exprs..)r)rhrNrNrOrszGroebnerBasis.exprscCs t|jS)N)rGr)rhrNrNrOrFszGroebnerBasis.polyscCs|jjS)N)rr<)rhrNrNrOr<szGroebnerBasis.genscCs|jjS)N)rrZ)rhrNrNrOrZszGroebnerBasis.domaincCs|jjS)N)rr=)rhrNrNrOr=szGroebnerBasis.ordercCs t|jS)N)rSr)rhrNrNrO__len__szGroebnerBasis.__len__cCs |jjrt|jSt|jSdS)N)rrFiterr)rhrNrNrOrs zGroebnerBasis.__iter__cCs|jjr|j}n|j}||S)N)rrFr)rhitemrrNrNrO __getitem__szGroebnerBasis.__getitem__cCst|jt|jfS)N)hashrrrr[)rhrNrNrOrkszGroebnerBasis.__hash__cCsPt||jr$|j|jko"|j|jkSt|rH|jt|kpF|jt|kSdSdS)NF)rCrarrr7rFrGr)rhrrNrNrOrs  zGroebnerBasis.__eq__cCs ||k S)NrN)rhrrNrNrOrszGroebnerBasis.__ne__cCsXdd}tdgt|j}|jj}x*|jD] }|j|d}||r,||9}q,Wt|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 cSsttt|dkS)NrQ)sumr`r)monomialrNrNrO single_varsz5GroebnerBasis.is_zero_dimensional..single_varr)r=)r rSr<rr=rFrr')rhrrr=rr rNrNrOrs   z!GroebnerBasis.is_zero_dimensionalc s|jj}t|}||kr |S|js.tdt|j}j}t | |dddl m }|j j|\}}x4t|D](\} } | jj} || || <q~Wt|||} fdd| D} |jsdd| D} |_|| S)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 ========== J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering z>can't convert Groebner bases of ideals with positive dimension)rZr=r)rcsg|]}tt|qSrN)r:rErD)rr|)rMrNrOr!sz&GroebnerBasis.fglm..cSsg|]}|jdddqS)T)r\rQ)r)rr|rNrNrOr$s)rr=r!rrArGrrZrrDrrrr<rrfr;rrVrrr) rhr=Z src_orderZ dst_orderrFrZrrr}rprrrN)rMrOfglms.    zGroebnerBasis.fglmTcsXt||j}|gt|j}|jj}d}|rV|jrV|jsVt | dd}ddl m }|j jj\}} x4t|D](\} }|jj}|||| <qW|d|dd\} } fdd | D} tt | } |r.yd d | D| } }Wntk r"Yn X| |} } jsLd d | D| fS| | fSdS) a# Reduces a polynomial modulo a Groebner basis. 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*f_1 + ... + q_n*f_n + r``, where ``r`` vanishes or ``r`` is a completely reduced polynomial with respect to ``G``. Examples ======== >>> 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 F)rZTr)rrQNcsg|]}tt|qSrN)r:rErD)rr)rMrNrOrZsz(GroebnerBasis.reduce..cSsg|] }|qSrN)r)rrrNrNrOr_scSsg|] }|qSrN)rd)rrrNrNrOrfs)r:rJrrGrrZrrrrDrrrr<r=rrfr;rrVrrErr$rFrd)rhrrrrFrZrrrr}rprrrrrN)rMrOreduce)s2  zGroebnerBasis.reducecCs||ddkS)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 rQr)r)rhrrNrNrOcontainsjszGroebnerBasis.containsN)T)rrrrrPrrrrLrrFr<rZr=rrr rkrrrrrrrNrNrNrOrps&       B Arcs^tgfddt|}|jr8t|f|SdkrHdd<t|}||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') c sgg}}xt|D]}gg}}xpt|D]b}|jrN|||q2|jr|jjr|jjr|jdkr||j| |jq2||q2W|s||q|d}x|ddD]}| |}qW|rt|}|j r| |}n| t ||}||qW|s$t ||} n^|d} x |ddD]}| |} q:W|rt|}|j rp| |} n| t ||} | j|ddS)NrrQr<rN)r rr rrrrrrcrrrr:rJrrer) rrMrZ poly_termsrr(Z poly_factorsraproductr)_polyrLrNrOrsB     zpoly.._polyrF)r?rrrHr:r@)rr<rLrMrN)rrLrOrs 4 r)r)N)N)FNNNFFF)NNFF)NN)T)rNrOT)rZ __future__rrZ sympy.corerrrrrr r r r Zsympy.core.mulr Zsympy.core.symbolrZsympy.core.basicrrrZsympy.core.sympifyrZsympy.core.decoratorsrZsympy.core.functionrZsympy.logic.boolalgrZsympy.polys.polyclassesrZsympy.polys.polyutilsrrrrrrZsympy.polys.rationaltoolsrZsympy.polys.rootisolationrZsympy.polys.groebnertoolsrrZsympy.polys.fglmtoolsrZsympy.polys.monomialsr Zsympy.polys.orderingsr!Zsympy.polys.polyerrorsr"r#r$r%r&r'r(r)r*r+r,Zsympy.utilitiesr-r.r/r0Z sympy.polysrErSZmpmath.libmp.libhyperr1Zsympy.polys.domainsr2r3r4Zsympy.polys.constructorr5r6r?Zsympy.core.compatibilityr7r8r9r:rrrrrrrrrrrrrrrrrrrrrrrr r r rrrrrrrrrrrrr!r"rr$r%rrrrrrrrr&r1r*rar,r8rCrKr_rbrdrerrrrrNrNrNrOs,               4     * ] ( _  5 5       # # # ' ' 4  &  ) T 2 N 2 t    .    /  " :),    P 7      ' O < 6