U 9%e@sdZddlmZmZddlmZddlmZddlm Z m Z m Z m Z ddl mZddlmZddlmZmZmZdd lmZmZmZmZmZdd lmZdd lmZmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'ddl(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z7ddl8m9Z9ddl:m;Z;mm?Z?ddl@mAZAddlBmCZDddlEmFZFddlGmHZHddlImJZJmKZKmLZLddlMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXddlYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ddl`maZaddlbmcZcdd ldmeZemfZfmgZgdd!lhmiZidd"ljmkZkmlZldd#l5Zmdd#lnZndd$lompZpd%d&ZqefGd'd(d(eZrefGd)d*d*erZsefd+d,Ztd-d.Zuefd/d0Zvd1d2Zwd3d4Zxefdd5d6Zyefd7d8Zzefd9d:Z{efd;d<Z|efd=d>Z}efd?d@Z~efdAdBZefdCdDZefdEdFZefdGdHZefdIdJZefdKdLZefdMdNZefdOdPZefdQdRZefdSdTZefdUdVZefdWdXZefdYdZd[d\Zefd]d^Zefd_d`ZefdadbZefddcddZefdedfZefddgdhZefdidjZefdkdlZefdmdnZefdodpZefdqdrZefdsdtZefdudvZefdwdxZefdydzZefd{d|Zefd}d~ZefddZddZddZddZddZddZddZddZddZefddZefddZefddZefdYdddZefdddZefdddZefdddZefdddZefdddZefddZefddZefddddZefddZefddZCefddZefGdddeZefddZddZd#S)z8User-friendly public interface to polynomial functions. )wrapsreducemul)Optional)SExprAddTuple)Basic) _sympifyit)Factors factor_nc factor_terms) pure_complexevalffastlog_evalf_with_bounded_errorquad_to_mpmath) Derivative)Mul _keep_coeff)ilcmIInteger equal_valued) RelationalEquality)ordered)DummySymbol)sympify_sympify)preorder_traversal bottom_up) BooleanAtom) polyoptions)construct_domain)FFQQZZ) DomainElement) matrix_fglm)groebner)Monomial) monomial_key)DMPDMFANP) OperationNotSupported DomainErrorCoercionFailedUnificationFailedGeneratorsNeededPolynomialErrorMultivariatePolynomialErrorExactQuotientFailedPolificationFailedComputationFailedGeneratorsError)basic_from_dict _sort_gens _unify_gens _dict_reorder_dict_from_expr_parallel_dict_from_expr)together)dup_isolate_real_roots_list)grouppublic filldedent)sympy_deprecation_warning)iterablesiftN) NoConvergencecstfdd}|S)Ncst|}t|tr||St|trz|j|f|j}WnTtk r|jrZtYSt | j }||}|tk rt dddd|YSX||SntSdS)Na@ Mixing Poly with non-polynomial expressions in binary operations is deprecated. Either explicitly convert the non-Poly operand to a Poly with as_poly() or convert the Poly to an Expr with as_expr(). z1.6z)deprecated-poly-nonpoly-binary-operations)Zdeprecated_since_versionZactive_deprecations_target) r" isinstancePolyr from_exprgensr8Z is_MatrixNotImplementedgetattras_expr__name__rI)fgZ expr_methodresultfuncT/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/polys/polytools.pywrapperDs(     z_polifyit..wrapper)r)rYr\rZrXr[ _polifyitCsr]cs^eZdZdZdZdZdZdZddZe ddZ e d d Z e d d Z d dZe ddZe ddZe ddZe ddZe ddZe ddZe ddZe ddZe dd Zfd!d"Ze d#d$Ze d%d&Ze d'd(Ze d)d*Ze d+d,Ze d-d.Ze d/d0Zd1d2Z d3d4Z!dyd6d7Z"d8d9Z#d:d;Z$dd?Z&d@dAZ'dBdCZ(dzdDdEZ)dFdGZ*dHdIZ+dJdKZ,dLdMZ-dNdOZ.dPdQZ/dRdSZ0d{dTdUZ1d|dVdWZ2d}dXdYZ3d~dZd[Z4dd\d]Z5d^d_Z6d`daZ7dbdcZ8dddeZ9dfdgZ:ddidjZ;ddkdlZdqdrZ?dsdtZ@ddudvZAdwdxZBdydzZCd{d|ZDd}d~ZEddZFddZGddZHddZIddZJddZKddZLddZMddZNddZOddZPddZQddZRddZSdddZTdddZUdddZVdddZWddZXdddZYddZZddZ[ddZ\ddZ]dddZ^ddZ_dddZ`ddZaddZbdddZcdddZddddZeddd„ZfdddĄZgddƄZhddȄZidddʄZjdd̄Zkdd΄ZlddЄZmemZnddd҄ZoddԄZpdddքZqddd؄ZrdddڄZsdd܄ZtddބZudddZvddZwdddZxdddZyddZzddZ{ddZ|ddZ}dddZ~ddZddZddZddZddZddZdddZddZddZddZddZdddZdd d Zd d Zd dZdddZdddZdddZdddZdddZdddZdddZdd Zd!d"Zd#d$Zdd%d&Zd'd(Zdd*d+Ze d,d-Ze d.d/Ze d0d1Ze d2d3Ze d4d5Ze d6d7Ze d8d9Ze d:d;Ze d<d=Ze d>d?Ze d@dAZe dBdCZe dDdEZe dFdGZdHdIZdJdKZedLdMZedNdOZedPdQZedRdSZedTdUZedVdWZedXedYdZZed[d\Zed]d^Zed_d`ZedadbZedcddZededfZedgedhdiZedgedjdkZedledmdnZedgedodpZdqdrZddsdtZddudvZdwdxZ‡ZS(rNaP Generic class for representing and operating on polynomial expressions. See :ref:`polys-docs` for general documentation. Poly is a subclass of Basic rather than Expr but instances can be converted to Expr with the :py:meth:`~.Poly.as_expr` method. .. deprecated:: 1.6 Combining Poly with non-Poly objects in binary operations is deprecated. Explicitly convert both objects to either Poly or Expr first. See :ref:`deprecated-poly-nonpoly-binary-operations`. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x, y Create a univariate polynomial: >>> Poly(x*(x**2 + x - 1)**2) Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ') Create a univariate polynomial with specific domain: >>> from sympy import sqrt >>> Poly(x**2 + 2*x + sqrt(3), domain='R') Poly(1.0*x**2 + 2.0*x + 1.73205080756888, x, domain='RR') Create a multivariate polynomial: >>> Poly(y*x**2 + x*y + 1) Poly(x**2*y + x*y + 1, x, y, domain='ZZ') Create a univariate polynomial, where y is a constant: >>> Poly(y*x**2 + x*y + 1,x) Poly(y*x**2 + y*x + 1, x, domain='ZZ[y]') You can evaluate the above polynomial as a function of y: >>> Poly(y*x**2 + x*y + 1,x).eval(2) 6*y + 1 See Also ======== sympy.core.expr.Expr reprPTgn$@cOst||}d|krtdt|ttttfr:|||St |t drnt|t r\| ||S| t||Sn&t|}|jr|||S|||SdS)z:Create a new polynomial instance out of something useful. orderz&'order' keyword is not implemented yet)excludeN)options build_optionsNotImplementedErrorrMr0r1r2r+_from_domain_elementrJstrdict _from_dict _from_listlistr!is_Poly _from_poly _from_exprclsr_rPargsoptrZrZr[__new__s      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) rMr0r8levlenr rrr_rP)ror_rPobjrZrZr[news  zPoly.newcCst|jf|jSN)r>r_ to_sympy_dictrPselfrZrZr[exprsz Poly.exprcCs|jf|jSrx)r|rPrzrZrZr[rpsz Poly.argscCs|jf|jSrxr^rzrZrZr[_hashable_contentszPoly._hashable_contentcOst||}|||S)(Construct a polynomial from a ``dict``. )rbrcrhrnrZrZr[ from_dicts zPoly.from_dictcOst||}|||S)(Construct a polynomial from a ``list``. )rbrcrirnrZrZr[ from_lists zPoly.from_listcOst||}|||S)*Construct a polynomial from a polynomial. )rbrcrlrnrZrZr[ from_polys zPoly.from_polycOst||}|||S+Construct a polynomial from an expression. )rbrcrmrnrZrZr[rOs zPoly.from_exprcCsx|j}|stdt|d}|j}|dkr>t||d\}}n |D]\}}||||<qF|jt |||f|S)r~z0Cannot initialize from 'dict' without generatorsrsNrq) rPr7rudomainr'itemsconvertrwr0r)ror_rqrPlevelrmonomcoeffrZrZr[rhs zPoly._from_dictcCs~|j}|stdnt|dkr(tdt|d}|j}|dkrTt||d\}}ntt|j|}|j t |||f|S)rz0Cannot initialize from 'list' without generatorsrsz#'list' representation not supportedNr) rPr7rur9rr'rjmaprrwr0r)ror_rqrPrrrZrZr[ris  zPoly._from_listcCs||jkr|j|jf|j}|j}|j}|j}|rj|j|krjt|jt|kr`|||S|j |}d|kr|r| |}n|dkr| }|S)rrT) __class__rwr_rPfieldrsetrmrSreorder set_domainto_field)ror_rqrPrrrZrZr[rls    zPoly._from_polycCst||\}}|||Sr)rBrh)ror_rqrZrZr[rm4szPoly._from_exprcCs>|j}|j}t|d}||g}|jt|||f|SNrs)rPrrurrwr0r)ror_rqrPrrrZrZr[re:s   zPoly._from_domain_elementcs tSrxsuper__hash__rzrrZr[rDsz Poly.__hash__cCsPt}|j}tt|D],}|D]}||r$|||jO}qq$q||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} )rrPrangerumonoms free_symbolsfree_symbols_in_domain)r{symbolsrPirrZrZr[rGs zPoly.free_symbolscCsP|jjt}}|jr.|jD]}||jO}qn|jrL|D]}||jO}q<|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_domr is_Compositerris_EXcoeffs)r{rrgenrrZrZr[rfs   zPoly.free_symbols_in_domaincCs |jdS)z Return the principal generator. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**2 + 1, x).gen x rrPrzrZrZr[rszPoly.gencCs|S)aGet the ground domain of a :py:class:`~.Poly` Returns ======= :py:class:`~.Domain`: Ground domain of the :py:class:`~.Poly`. Examples ======== >>> from sympy import Poly, Symbol >>> x = Symbol('x') >>> p = Poly(x**2 + x) >>> p Poly(x**2 + x, x, domain='ZZ') >>> p.domain ZZ ) get_domainrzrZrZr[rsz Poly.domaincCs$|j|j|jj|jjf|jS)z3Return zero polynomial with ``self``'s properties. )rwr_zerortrrPrzrZrZr[rsz Poly.zerocCs$|j|j|jj|jjf|jS)z2Return one polynomial with ``self``'s properties. )rwr_onertrrPrzrZrZr[rszPoly.onecCs$|j|j|jj|jjf|jS)z3Return unit polynomial with ``self``'s properties. )rwr_unitrtrrPrzrZrZr[rsz 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)rUrV_perFGrZrZr[unifysz Poly.unifyc stjs\z(jjjjjjjfWStk rZtdfYnXtjt rtjt rt j j }jj jj|t |d}j |krtjj |\}}jjkrfdd|D}t ttt|||}n j}j |krvtjj |\}}jjkrZfdd|D}t ttt|||} n j} ntdfj|dffdd } | || fS)NCannot unify %s with %srscsg|]}|jjqSrZrr_r.0c)rrUrZr[ szPoly._unify..csg|]}|jjqSrZrr)rrVrZr[rscsB|dk r2|d|||dd}|s2||Sj|f|Srto_sympyrwr_rrPremoverorZr[rs  zPoly._unify..per)r!rkr_rr from_sympyr5r6rMr0r@rPrrurAto_dictrgrjziprr) rUrVrPrtZf_monomsZf_coeffsrZg_monomsZg_coeffsrrrZ)rorrUrVr[rsB("     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') Nrs)rPr_rrrrw)rUr_rPrrZrZr[r szPoly.percCs&t|jd|i}||j|jS)z Set the ground domain of ``f``. r)rbrcrPrr_rr)rUrrqrZrZr[r'szPoly.set_domaincCs|jjS)z Get the ground domain of ``f``. )r_rrUrZrZr[r,szPoly.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) )rbZModulus preprocessrr()rUmodulusrZrZr[ set_modulus0s 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)rZis_FiniteFieldrZcharacteristicr8)rUrrZrZr[ get_modulusAs zPoly.get_moduluscCsP||jkr@|jr|||Sz|||WStk r>YnX|||S)z)Internal implementation of :func:`subs`. )rP is_numberevalreplacer8rSsubs)rUoldrwrZrZr[ _eval_subsVs  zPoly._eval_subscs4|j\}fddt|jD}|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') csg|]\}}|kr|qSrZrZ)rjrJrZr[rrsz Poly.exclude..r)r_ra enumeraterPr)rUrwrPrZrr[racsz Poly.excludecKs|dkr$|jr|j|}}ntd||ks6||jkr:|S||jkr||jkr|}|jrf||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 caserzCannot replace %s with %s in %s) is_univariaterr8rPrrrrjindexrr_)rUxy_ignorerrPrZrZr[rvs z Poly.replacecOs|j||S)z-Match expression from Poly. See Basic.match())rSmatch)rUrpkwargsrZrZr[rsz Poly.matchcOs|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') rZrz7generators list can differ only up to order of elementsrsr)rbOptionsr?rPrr8rgrjrrAr_rrr0rru)rUrPrprqr_rZrZr[rs  z Poly.reordercCs|jdd}||}i}|D]4\}}t|d|rFtd|||||d<q"|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)nativeNzCannot left trim %srs) as_dict _gen_to_levelranyr8rPrwr0rrur_r)rUrr_rtermsrrrPrZrZr[ltrims   z Poly.ltrimc Gst}|D]D}z|j|}Wn$tk rBtd||fYq X||q |D]*}t|D]\}}||krd|rddSqdqXdS)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 %s doesn't have %s as generatorFT)rrPr ValueErrorr=addrr)rUrPindicesrrrreltrZrZr[ 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_rr3rrUrWrZrZr[rs   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') r)rr_rr3rrrZrZr[rs   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_rr3rrrZrZr[r's   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') TrN)rZ compositer)r'rrrrrP)rUrrr_rZrZr[retract<s   z Poly.retractcCsh|dkrd||}}}n ||}t|t|}}t|jdrT|j|||}n t|d||S)z1Take a continuous subsequence of terms of ``f``. Nrslice)rintrr_rr3r)rUrmnrrWrZrZr[rTs   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|qSrZr_rrrrrZr[rxszPoly.coeffs..r`)r_rrUr`rZrr[rdsz 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_rrrZrZr[rzsz 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|fqSrZrrrrrrZr[rszPoly.terms..r)r_rrrZrr[rsz 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|qSrZrrrrZr[rsz#Poly.all_coeffs..)r_ all_coeffsrrZrr[rszPoly.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_monomsrrZrZr[rszPoly.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|fqSrZrrrrZr[rsz"Poly.all_terms..)r_ all_termsrrZrr[rszPoly.all_termscOsri}|D]L\}}|||}t|tr2|\}}n|}|r ||krL|||<q td|q |j|f|pj|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)rrMtupler8rrP)rUrYrPrprrrrWrZrZr[termwises    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 )rurrrZrZr[lengthsz 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} rN)r_rry)rUrrrZrZr[r sz Poly.as_dictcCs|r|jS|jSdS)z%Switch to a ``list`` representation. N)r_Zto_listZ to_sympy_list)rUrrZrZr[as_lists z Poly.as_listc Gs|s |jSt|dkrt|dtr|d}t|j}|D]D\}}z||}Wn$tk rxt d||fYq>X|||<q>t |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 rsrr) r|rurMrgrjrPrrrr=r>r_ry)rUrPmappingrvaluerrZrZr[rS%s   z Poly.as_exprcOsBz&t|f||}|jsWdS|WSWntk r<YdSXdS)a{Converts ``self`` to a polynomial or returns ``None``. >>> from sympy import sin >>> from sympy.abc import x, y >>> print((x**2 + x*y).as_poly()) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + x*y).as_poly(x, y)) Poly(x**2 + x*y, x, y, domain='ZZ') >>> print((x**2 + sin(y)).as_poly(x, y)) None N)rNrkr8)r{rPrppolyrZrZr[as_polyKs z Poly.as_polycCs,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_rr3rrrZrZr[res   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_rr3rrUrrWrZrZr[rzs  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') z Cannot inject generators over %sinjectfront) r_r is_Numericalrkr4rrr3rrPrw)rUrrrWrPrZrZr[rs    z Poly.injectcGs|jj}|jstd|t|}|jd||krJ|j|dd}}n4|j| d|krv|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]') zCannot eject generators over %sNTFz'can only eject front or back generatorsejectr) r_rrr4rurPrdrrrr3rw)rUrPrkZ_gensrrWrZrZr[rs     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_rr3rrrZrZr[rs  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_rr3rrUrrWrZrZr[rs  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_rr3rrrZrZr[rs  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_rr3rrrZrZr[rs  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_rr3rrrZrZr[r2s  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_r r3rrrZrZr[r Js  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_r r3rrrZrZr[r ds   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_r r3rrrZrZr[r ys   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)r!rkrrrr_rr3rUrVrrrrrWrZrZr[rs    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)r!rkrrrr_r r3r rZrZr[r s    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') r)r!rkrrrr_rr3r rZrZr[rs    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_rr3rrrZrZr[rs   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_rr3rrUrrWrZrZr[rs   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)rrr_rr3)rUrVrrrrqrrZrZr[r s   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)rrr_rr3r rZrZr[r7s    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)rrr_rr3r rZrZr[r^s    z Poly.pquoc Csx||\}}}}t|jdrfz||}Wqptk rb}z|||W5d}~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)rrr_rr:rwrSr3)rUrVrrrrrWexcrZrZr[rzs ( z Poly.pexquoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrX||\}} n t|d|rz|| } } 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) ris_Ringis_Fieldrrr_rr3rr5) rUrVautorrrrrrrQRrZrZr[rs   zPoly.divc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|rz |}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) rrrrrr_rr3rr5) rUrVrrrrrrrrZrZr[rs    zPoly.remc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrT||}n t|d|rz |}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) rrrrrr_rr3rr5) rUrVrrrrrrrrZrZr[rs    zPoly.quoc Cs||\}}}}d}|r<|jr<|js<||}}d}t|jdrz||}Wqtk r} z| | | W5d} ~ XYqXn t |d|rz | }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) rrrrrr_r r:rwrSr3rr5) rUrVrrrrrrrrrZrZr[r  s" (  z Poly.exquocCst|trXt|j}| |kr*|krDnn|dkr>||S|Sqtd|||fn4z|jt|WStk rtd|YnXdS)z3Returns level associated with the given generator. rz -%s <= gen < %s expected, got %sz"a valid generator expected, got %sN)rMrrurPr8rr!r)rUrrrZrZr[r4s  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_r!r3)rUrrrZrZr[r!Hs   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_r"r3rrZrZr[r"cs  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_r#r3rrZrZr[r#vs  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 homogenizerhomogeneous_orderN) rMr TypeErrortyperPrrurr_rr$r3)rUsrrPrZrZr[r$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 r%N)rr_r%r3rrZrZr[r%s  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)rrr_r)r3rr)rUr`rWrZrZr[r)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_r*r3rrrrZrZr[r*s   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 rECN)rr_rr3rrZrZr[r,s 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.rP exponents)rUrrZrZr[coeff_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 r-z,exponent of each generator must be specified) rr_rurPrr-rjrrr3rr)rUNrWrZrZr[r-+s   zPoly.nthrscCs tddS)NzyEither convert to Expr with `as_expr` method to use Expr's coeff method or else use the `coeff_monomial` method of Polys.rd)rUrrrightrZrZr[rMsz 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 rr.rrPrrZrZr[LMYszPoly.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+r3rrZrZr[EMmszPoly.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) rrr.rPrUr`rrrZrZr[LT}szPoly.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+r6r7rZrZr[ETszPoly.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_r:r3rrrrZrZr[r:s   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_r;r3rrrrZrZr[r;s   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_rrrOnerhas_assoc_Ringget_ringrr<r3rrr)r{rrUrrrWrZrZr[r<s      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]') Tr)rrr>r<r)r{rVrUrrabrZrZr[rat_clear_denomss   zPoly.rat_clear_denomscOs|}|ddr"|jjjr"|}t|jdr|sF||jjddS|j}|D]8}t|t rh|\}}n |d}}|t || |}qP||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 integratersrN) getr_rrrrrrDrMrrrr3)r{specsrprUr_specrrrZrZr[rD s     zPoly.integratecOs|ddst|f||St|jdr|s@||jjddS|j}|D]8}t|trb|\}}n |d}}|t|| |}qJ||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') evaluateTdiffrsrEN) rFrrr_rrJrMrrrr3)rUrGrr_rHrrrZrZr[rJC s      z Poly.diffc CsR|}|dkrt|tr<|}|D]\}}|||}q"|St|ttfr|}t|t|jkrhtdt |j|D]\}}|||}qt|Sd|} }n | |} t |j dst |dz|j || } Wnvtk rB|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 providedrrzCannot evaluate at %s in %sr)rMrgrrrrjrurPrrrrr_r3r5r4rr'rZunify_with_symbolsrrr) r{rrArrUrrrvaluesrrWZa_domainZ new_domainrZrZr[rk 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)rUrLrZrZr[__call__ 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)rrrrr_rNr3) rUrVrrrrrr(hrZrZr[rN 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)rrrrr_rPr3) rUrVrrrrrr(trOrZrZr[rP 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)rrrrr_rRr3)rUrVrrrrrrWrZrZr[rR s    z Poly.invertcCs2t|jdr|jt|}n t|d||S)ad Compute ``f**(-1)`` mod ``x**n``. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(1, x).revert(2) Poly(1, x, domain='ZZ') >>> Poly(1 + x, x).revert(1) Poly(1, x, domain='ZZ') >>> Poly(x**2 - 2, x).revert(2) Traceback (most recent call last): ... NotReversible: only units are reversible in a ring >>> Poly(1/x, x).revert(1) Traceback (most recent call last): ... PolynomialError: 1/x contains an element of the generators set revert)rr_rSrr3rrrZrZr[rS+ 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)rrr_rTr3rjrr rZrZr[rTM 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 includePRSrrK)rrr_rUr3rjr) rUrVrWrrrrrWrrZrZr[rUf 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 discriminantrrK)rr_rXr3rrrZrZr[rX 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.dispersionrY)rUrVrYrZrZr[rY 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)rZr[)rUrVr[rZrZr[r[ 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)rrr_r\r3) rUrVrrrrrOcffcfgrZrZr[r\6 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)rrr_r_r3r rZrZr[r_S 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)rrr_r`r3r rZrZr[r`j 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_rrrrar3r)rUprWrZrZr[ra 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_rrrrrcr3rr{rrUrWrZrZr[rc 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_rer3rrrrZrZr[re 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_rfr3rrr)rUcontrWrZrZr[rf 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)rrr_rhr3r rZrZr[rh 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_rir3rjrrrrZrZr[ri 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_rjr3r)rUrArWrZrZr[rj 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_rkr3r)rUrbrPrrrWrZrZr[rk 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_rrrrrmr3rjrrrdrZrZr[rm: 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|]\}}||fqSrZrrrVrrrZr[rl sz!Poly.gff_list..)rr_rnr3rrZrr[rnW 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_rqr3r)rUrrZrZr[rqn 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_rrr3r)rUr(rVrrZrZr[rr 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_rsr3rrrZrZr[rs 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|]\}}||fqSrZrorprrZr[r sz!Poly.sqf_list..)rr_rtr3rr)rUallrfactorsrZrr[rt 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|]\}}||fqSrZrorprrZr[r sz)Poly.sqf_list_include..)rr_rwr3)rUrurvrZrr[rw s  zPoly.sqf_list_includecsptjdrFzj\}}WqPtk rBtjdfgfYSXn 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_listrscsg|]\}}||fqSrZrorprrZr[r sz$Poly.factor_list..) rr_rxr4rr=r3rr)rUrrvrZrr[rx s  zPoly.factor_listcsXtjdr>> 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_includerscsg|]\}}||fqSrZrorprrZr[r7 sz,Poly.factor_list_include..)rr_ryr4r3)rUrvrZrr[ry 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)] Nr!'eps' must be a positive rational intervalsruepsinfsupfastsqfcSs|\}}t|t|fSrxr)r)intervalr(rQrZrZr[_reale szPoly.intervals.._realcSs@|\\}}\}}t|tt|t|tt|fSrxr)rr) rectangleuvr(rQrZrZr[_complexl sz Poly.intervals.._complexcSs$|\\}}}t|t|f|fSrxr)rr(rQrrZrZr[ru s cSsH|\\\}}\}}}t|tt|t|tt|f|fSrxr)rrrr(rQrrZrZr[r| s ) r)rrrr_r{r3rjr) rUrur}r~rrrrWrrZ real_partZ complex_partrZrZr[r{9 s>     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 supportedNrrzrs refine_root)r}stepsr) is_sqfr8r)rrrrr_rr3r) rUr(rQr}rr check_sqfrTrZrZr[r 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_rootsr~rcount_complex_roots)r!rNegativeInfinity as_real_imagr)rrjrInfinityrr_rr3rrr)rUr~rZinf_realZsup_realreZimcountrZrZr[ 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)rUrrrZrZr[root 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)] rFmultipleN)rrrCRootOf real_rootsrF)rUrrZrealsrZrZr[rszPoly.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)] rFrN)rrrr all_rootsrF)rUrrrootsrZrZr[rszPoly.all_roots2c s|jrtd||dkr"gS|jjtkrBdd|D}n|jjtkrdd|D}t|fdd|D}nNfdd|D}zdd|D}Wn$t k rt d |jjYnXt j j }t j _ dd lmzz>t j|||d |d d }tttt|fddd}Wn|tk rz>t j|||d |dd }tttt|fddd}Wn&tk rtd|fYnXYnXW5|t j _ 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] z$Cannot compute numerical roots of %srcSsg|] }t|qSrZrrrrZrZr[rZszPoly.nroots..cSsg|] }|jqSrZ)rrrZrZr[r\scsg|]}t|qSrZrr)facrZr[r^scsg|]}|jdqS)r)rrrrrZr[r`scSsg|]}tj|qSrZ)mpmathZmpcrrZrZr[rcsz!Numerical domain expected, got %ssignF )maxstepscleanuperrorZ extrapreccs$|jr dnd|jt|j|jfSNrsrimagrealr rrrZr[uzPoly.nroots..keyrcs$|jr dnd|jt|j|jfSrrrrrZr[r|rz7convergence to root failed; try n < %s or maxsteps > %s)is_multivariater9r!r_rr*rr)rr&r4rmpdpsZ$sympy.functions.elementary.complexesrZ polyrootsrjrr!sortedrL)rUrrrrZdenomsrrrZ)rrrr[nroots6sh           z Poly.nrootscCsP|jrtd|i}|dD](\}}|jr"|\}}||| |<q"|S)a Compute roots of ``f`` by factorization in the ground domain. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots() {0: 2, 1: 2} z!Cannot compute ground roots of %srs)rr9rx is_linearr)rUrfactorrrArBrZrZr[ 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 polynomialrsz&'n' must an integer and n >= 1, got %srQ) rr9r! is_IntegerrrrrrUrrOr)rUrr0rrQrrZrZr[nth_power_roots_polys  zPoly.nth_power_roots_polyc s|jrtd|j}|j|}|d}td|di\}}}}t|}|d|dfdd} | || |} } | j | j d| j | j d|kS)a Decide whether two roots of this polynomial are equal. Examples ======== >>> from sympy import Poly, cyclotomic_poly, exp, I, pi >>> f = Poly(cyclotomic_poly(5)) >>> r0 = exp(2*I*pi/5) >>> indices = [i for i, r in enumerate(f.all_roots()) if f.same_root(r, r0)] >>> print(indices) [3] Raises ====== DomainError If the domain of the polynomial is not :ref:`ZZ`, :ref:`QQ`, :ref:`RR`, or :ref:`CC`. MultivariatePolynomialError If the polynomial is not univariate. PolynomialError If the polynomial is of degree < 2. zMust be a univariate polynomial rscstt|dS)NrE)rrrrErZr[rrz Poly.same_root..) rr9r_Zmignotte_sep_bound_squaredr get_fieldrrrrr) rUrArBZ dom_delta_sqZdelta_sqZeps_sqrrrZevABrZrEr[ same_roots  zPoly.same_rootc 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) rrrr3r>r?rrr) rUrVrrrrrrWcpcqrbrrZrZr[rs     z Poly.cancelcCsh|jr|jttfkrtd|jr6|jtkr6|tjfS|}|\}}| t |j | |fSdS)aQ Turn any univariate polynomial over :ref:`QQ` or :ref:`ZZ` into a monic polynomial over :ref:`ZZ`, by scaling the roots as necessary. Explanation =========== This operation can be performed whether or not *f* is irreducible; when it is, this can be understood as determining an algebraic integer generating the same field as a root of *f*. Examples ======== >>> from sympy import Poly, S >>> from sympy.abc import x >>> f = Poly(x**2/2 + S(1)/4 * x + S(1)/8, x, domain='QQ') >>> f.make_monic_over_integers_by_scaling_roots() (Poly(x**2 + 2*x + 4, x, domain='ZZ'), 4) Returns ======= Pair ``(g, c)`` g is the polynomial c is the integer by which the roots had to be scaled z,Polynomial must be univariate over ZZ or QQ.N) rrr*r)ris_monicrrcr<rkrNrr)rUfmrrrZrZr[)make_monic_over_integers_by_scaling_roots!s  z.Poly.make_monic_over_integers_by_scaling_rootscCsddlm}m}m}m}|jr2|jr2|jtt fkr:t d||||d}t | } | } | | krvt d| dnx| dkrt dnf| dkrdd lm} | jd } } nD| d krdd lm}|jd } } n"|\}}|| |||d\} } |r| n| }|| fS)a Compute the Galois group of this polynomial. Examples ======== >>> from sympy import Poly >>> from sympy.abc import x >>> f = Poly(x**4 - 2) >>> G, _ = f.galois_group(by_name=True) >>> print(G) S4TransitiveSubgroups.D4 See Also ======== sympy.polys.numberfields.galoisgroups.galois_group r)_galois_group_degree_3_galois_group_degree_4_lookup(_galois_group_degree_5_lookup_ext_factor_galois_group_degree_6_lookupz>> from sympy import Poly >>> from sympy.abc import x >>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False )r_is_zerorrZrZr[r~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_onerrZrZr[rsz 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_rrrZrZr[rsz 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_rrrZrZr[rsz 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_primitiverrZrZr[rszPoly.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_groundrrZrZr[rszPoly.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_rrrZrZr[rszPoly.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_quadraticrrZrZr[rszPoly.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_monomialrrZrZr[rszPoly.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_homogeneousrrZrZr[r+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_rrrZrZr[rCszPoly.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 rsrurPrrZrZr[rVszPoly.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 rsrrrZrZr[rmszPoly.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_cyclotomicrrZrZr[rszPoly.is_cyclotomiccCs|Srx)r rrZrZr[__abs__sz Poly.__abs__cCs|Srx)r rrZrZr[__neg__sz Poly.__neg__cCs ||SrxrrUrVrZrZr[__add__sz Poly.__add__cCs ||SrxrrrZrZr[__radd__sz Poly.__radd__cCs ||Srxr rrZrZr[__sub__sz Poly.__sub__cCs ||SrxrrrZrZr[__rsub__sz Poly.__rsub__cCs ||SrxrrrZrZr[__mul__sz Poly.__mul__cCs ||SrxrrrZrZr[__rmul__sz Poly.__rmul__rcCs |jr|dkr||StSdS)Nr)rrrQ)rUrrZrZr[__pow__s z Poly.__pow__cCs ||SrxrrrZrZr[ __divmod__szPoly.__divmod__cCs ||SrxrrrZrZr[ __rdivmod__szPoly.__rdivmod__cCs ||SrxrrrZrZr[__mod__sz Poly.__mod__cCs ||SrxrrrZrZr[__rmod__sz Poly.__rmod__cCs ||SrxrrrZrZr[ __floordiv__szPoly.__floordiv__cCs ||SrxrrrZrZr[ __rfloordiv__szPoly.__rfloordiv__rVcCs||SrxrSrrZrZr[ __truediv__szPoly.__truediv__cCs||SrxrrrZrZr[ __rtruediv__szPoly.__rtruediv__otherc Csx||}}|jsHz|j||j|d}Wntttfk rFYdSX|j|jkrXdS|jj|jjkrldS|j|jkSNrF) rkrrPrr8r4r5r_r)r{rrUrVrZrZr[__eq__s  z Poly.__eq__cCs ||k SrxrZrrZrZr[__ne__sz Poly.__ne__cCs|j Srx)rrrZrZr[__bool__sz Poly.__bool__cCs|s ||kS|t|SdSrx) _strict_eqr!rUrVstrictrZrZr[eqszPoly.eqcCs|j||d S)Nr )r r rZrZr[neszPoly.necCs*t||jo(|j|jko(|jj|jddSNTr)rMrrPr_r rrZrZr[r szPoly._strict_eq)NN)N)N)N)N)N)N)FF)F)F)T)T)T)T)r)N)N)rsF)N)N)N)N)F)NT)T)T)T)F)N)N)T)T)F)F)FNNNFF)NNFF)NN)T)TT)TT)rrT)F)FrF)F)F)rT __module__ __qualname____doc__ __slots__is_commutativerkZ _op_priorityrr classmethodrwpropertyr|rpr}rrrrOrhrirlrmrerrrrrrrrrrrrrrrrrarrrrrrrrrrrrrrrrrrrrrSrrrrrrrrrrr r r rr rrrrrrrrrrr rr!r"r#r$r%r)r*r,r/r-rr4r5r8r9r:r;r<rCrDrJZ_eval_derivativerrMrNrPrRrSrTrUrXrYr[r\r_r`rarcrerfrhrirjrkrmrnrqrrrsrtrwrxryr{rrrrrrrrrrrrrrrrrrrrrrrrrrrrr]rrrrrrr rQrrrrrrrrrrrr r rr  __classcell__rZrZrr[rNes5                   3   #$"     %  & %*' ' % % * "  %"     ''(& K  ! " % K K    #  !  L%?P  ( 3% '6        rNcsVeZdZdZddZfddZeddZede 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_rzrZrZr[r} szPurePoly._hashable_contentcs tSrxrrzrrZr[rszPurePoly.__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} )rrzrZrZr[rszPurePoly.free_symbolsrc Cs||}}|jsHz|j||j|d}Wntttfk rFYdSXt|jt|jkr`dS|jj |jj krz|jj |jj |j}Wnt k rYdSX| |}| |}|j|jkSr) rkrrPrr8r4r5rur_rrr6r)r{rrUrVrrZrZr[r's    zPurePoly.__eq__cCst||jo|jj|jddSr)rMrr_r rrZrZr[r ?szPurePoly._strict_eqcst|}|js\z(|jj|j|j|j|jj|fWStk rZtd||fYnXt|j t|j krtd||ft |jt rt |jt std||f|j |j }|jj |jj|}|j|}|j|}||dffdd }||||fS)NrcsB|dk r2|d|||dd}|s2||Sj|f|SrrrrrZr[rYs  zPurePoly._unify..per)r!rkr_rrrr5r6rurPrMr0rrr)rUrVrPrrrrrZrr[rBs"(   zPurePoly._unify)rTrrrr}rrrr rQrr rrrZrZrr[rs   rcOst||}t||Sr)rbrc_poly_from_exprr|rPrprqrZrZr[poly_from_expres 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)rNTrF)r!rMr r;rkrrlrPrrexpandrBrjrrr'rrrgrNrh)r|rqorigrr_rrrrZrZr[rls2     rcOst||}t||S)(Construct polynomials from expressions. )rbrc_parallel_poly_from_expr)exprsrPrprqrZrZr[parallel_poly_from_exprs r"cCst|dkr~|\}}t|tr~t|tr~|j||}|j||}||\}}|j|_|j|_|jdkrrd|_||g|fSt |g}}gg}}d}t |D]T\}} t | } t| t r| j r||q|||jr| } nd}|| q|r t|||d|r.|D]}||||<qt||\} }|jsRt|||dddlm} |jD]} t| | rdtdqdgg} }g}g}| D]@}t tt |\}}| ||||t|q|j}|dkrt| |d\|_} nt t|j| } |D]$} || d| | | d} qg}t||D]2\}}tt t||}t||}||qD|jdkrt||_||fS) rrNTFr Piecewisez&Piecewise generators do not make senser)rurMrNrrlrrPrrrjrr!r rkappendrr;rSrC$sympy.functions.elementary.piecewiser$r8rrextendr'rrrgrhbool)r!rqrUrVZorigsZ_exprsZ_polysfailedrr|repsr$rZ coeffs_listlengthsrrr_rrrrrrZrZr[r sv                    r cCst|}||kr|||<|S)z7Add a new ``(key, value)`` pair to arguments ``dict``. )rg)rprrrZrZr[ _update_argssr,cCst|dd}t|ddj}|jr0|}|j}n*|j}|sZ|rLt|\}}nt||\}}|rn|rhtjStjS|s|jr||jkrt|\}}||jkrtjSn4|jst |j dkrt t d|t t|j |f||}t|trt|StjS)a Return the degree of ``f`` in the given variable. The degree of 0 is negative infinity. Examples ======== >>> from sympy import degree >>> from sympy.abc import x, y >>> degree(x**2 + y*x + 1, gen=x) 2 >>> degree(x**2 + y*x + 1, gen=y) 1 >>> degree(0, x) -oo See also ======== sympy.polys.polytools.Poly.total_degree degree_list Trrsz 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). )r! is_NumberrkrSrrZerorrPrurr&rHnextrr!rMrr)rUrZ gen_is_NumrbZisNumrrWrZrZr[r!s.    r!cGsHt|}|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 >>> total_degree(1) 0 >>> total_degree(x + x*y) 2 >>> total_degree(x + x*y, x) 1 If the expression is a Poly and no variables are given then the generators of the Poly will be used: >>> p = Poly(x + x*y, y) >>> total_degree(p) 1 To deal with the underlying expression of the Poly, convert it to an Expr: >>> total_degree(p.as_expr()) 2 This is done automatically if any variables are given: >>> total_degree(p, x) 1 See also ======== degree r)r!rkrSr-rPrNr#r)rUrPrbrvrZrZr[r#>s( r#c Oslt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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) rr"rsN) rb allowed_flagsrr;r<r"rrr)rUrPrprrqrdegreesrZrZr[r"ssr"c Osdt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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 rr)rsNr)rbr1rr;r<r)r`rUrPrprrqrrZrZr[r)s r)c Oslt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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 rr4rsNr)rbr1rr;r<r4r`rS)rUrPrprrqrrrZrZr[r4sr4c Ostt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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 rr8rsNr)rbr1rr;r<r8r`rS)rUrPrprrqrrrrZrZr[r8sr8c Ost|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~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) rrrN)rbr1r"r;r<rrrS rUrVrPrprrrqrrrrZrZr[rs rc Os~t|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~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 rrrN)rbr1r"r;r<rrrS rUrVrPrprrrqrrrZrZr[rs  rc Ost|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~XYnXz||}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 rrrN) rbr1r"r;r<rr:rrS rUrVrPrprrrqrrrZrZr[rs rc Os~t|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~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 rrrN)rbr1r"r;r<rrrSr6rZrZr[r:s  rc Ost|ddgz t||ff||\\}}}Wn.tk r^}ztdd|W5d}~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) rrrrNr) rbr1r"r;r<rrrrSr4rZrZr[r]s rc Ost|ddgz t||ff||\\}}}Wn.tk r^}ztdd|W5d}~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 rrrrNr7) rbr1r"r;r<rrrrSr5rZrZr[r}s rc Ost|ddgz t||ff||\\}}}Wn.tk r^}ztdd|W5d}~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 rrrrNr7) rbr1r"r;r<rrrrSr6rZrZr[rs rc Ost|ddgz t||ff||\\}}}Wn.tk r^}ztdd|W5d}~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 rrr rNr7) rbr1r"r;r<r rrrSr6rZrZr[r s r c Ost|ddgz t||ff||\\}}}Wntk r}zht|j\}\} } z|| | \} } Wn tk rtdd|YnX| | | | fWYSW5d}~XYnX|j||j d\} } |j s| | fS| | fSdS)aT Half extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``. Examples ======== >>> from sympy import half_gcdex >>> from sympy.abc import x >>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x + 1) rrrNrNr7) rbr1r"r;r'r!rNrdr<rrrrS) rUrVrPrprrrqrrrArBr(rOrZrZr[rNs .rNc Ost|ddgz t||ff||\\}}}Wntk r}zrt|j\}\} } z|| | \} } } Wn tk rtdd|Yn&X| | | | | | fWYSW5d}~XYnX|j||j d\} } } |j s| | | fS| | | fSdS)aZ Extended Euclidean algorithm of ``f`` and ``g``. Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``. Examples ======== >>> from sympy import gcdex >>> from sympy.abc import x >>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (3/5 - x/5, x**2/5 - 6*x/5 + 2, x + 1) rrrPrNr7) rbr1r"r;r'r!rPrdr<rrrrS)rUrVrPrprrrqrrrArBr(rQrOrZrZr[rPs 6rPc Ost|ddgz t||ff||\\}}}Wnrtk r}zTt|j\}\} } z||| | WWY&Stk rt dd|YnXW5d}~XYnX|j||j d} |j s| S| SdS)a Invert ``f`` modulo ``g`` when possible. Examples ======== >>> from sympy import invert, S, mod_inverse >>> from sympy.abc import x >>> invert(x**2 - 1, 2*x - 1) -4/3 >>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor For more efficient inversion of Rationals, use the :obj:`~.mod_inverse` function: >>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2 See Also ======== sympy.core.numbers.mod_inverse rrrRrNr7) rbr1r"r;r'r!rrRrdr<rrrS) rUrVrPrprrrqrrrArBrOrZrZr[rR.s! $rRc Ost|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~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] rrTrNcSsg|] }|qSrZrrrrZrZr[r|sz!subresultants..)rbr1r"r;r<rTr rUrVrPrprrrqrrWrZrZr[rTcs  rTFrVc Ost|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~XYnX|rv|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 rrUrNrVcSsg|] }|qSrZrr8rZrZr[rszresultant..)rbr1r"r;r<rUrrS) rUrVrWrPrprrrqrrWrrZrZr[rUs  rUc Ostt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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 rrXrsN)rbr1rr;r<rXrrSrUrPrprrqrrWrZrZr[rXsrXc Ost|dgz t||ff||\\}}}Wntk r}zrt|j\}\} } z|| | \} } } Wn tk rtdd|Yn&X| | | | | | fWYSW5d}~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) rr\rN) rbr1r"r;r'r!r\rdr<rrrS)rUrVrPrprrrqrrrArBrOr]r^rZrZr[r\s 6r\c st|}fdd}||}|dk r*|Stdgzt|f\}}t|dkrtdd|Dr|dfd d |ddD}td d|Drd}|D]} t|| d }qt|WSWnTt k r$} z4|| j }|dk r|WYSt d t|| W5d} ~ XYnX|sF|j s:t jStd |dS|d |dd}}|D]} || }|jr`qq`|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 cslshsht|\}}|s|jS|jrh|d|dd}}|D]}|||}||r>q^q>||SdSNrrs)r'rrr_rrseqrnumbersrWnumberrprPrZr[try_non_polynomial_gcds    z(gcd_list..try_non_polynomial_gcdNrrscss|]}|jo|jVqdSrx is_algebraic is_irrationalrrrZrZr[ szgcd_list..r+csg|]}|qSrZratsimprErArZr[rszgcd_list..css|] }|jVqdSrx is_rationalrfrcrZrZr[rFsrgcd_listr)r!rbr1r"rurur`as_numer_denomr r;r!r<rrr.rNr_rrS) r=rPrprArWrrqlstlcrMrrrZrArprPr[rNsB   "   rNc OsVt|dr,|dk r|f|}t|f||S|dkr>> 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 argumentsrrr_r)rrNr&rbr1r"rr!rCrDrHrKr rOr;r'r!rr_rdr<rrS rUrVrPrprrrqrArBrMrrrWrZrZr[r_Bs0   $ r_c st|}ttdfdd }||}|dk r4|Stdgzt|f\}}t|dkrtdd|Dr|d fd d |dd D}td d|Drd}|D]} t|| d}q|WSWnTt k r*} z4|| j }|dk r |WYSt d t|| W5d} ~ XYnX|sL|j s@tjStd|dS|d|dd}}|D]} || }qf|j s|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 )returncsds`s`t|\}}|s$||jS|jr`|d|dd}}|D]}|||}qD||SdSr;)r'rrrr`r<r@rZr[try_non_polynomial_lcms   z(lcm_list..try_non_polynomial_lcmNrrscss|]}|jo|jVqdSrxrBrErZrZr[rFszlcm_list..r+csg|]}|qSrZrGrErIrZr[rszlcm_list..css|] }|jVqdSrxrJrLrZrZr[rFslcm_listrr)r!rrrbr1r"rurur`rOr;r!r<rrr=rNrS) r=rPrprVrWrrqrPrQrMrrrZrRr[rWvs>   " rWc OsRt|dr,|dk r|f|}t|f||S|dkr>> 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 rSNz2lcm() takes 2 arguments or a sequence of argumentsrrsr`r)rrWr&rbr1r"rr!rCrDrHrKrOr;r'r!rr`rdr<rrSrTrZrZr[r`s0   $ r`c st|}t|tr2tfdd|j|jfDSt|trJtd|ft|trZ|jr^|S ddr|j fdd|j D} ddd<t |fS d d }td gzt|f\}}Wn.tk r}z|jWYSd }~XYnX| \} }|jjrZ|jjr:|jd d \} }|\} }|jjr`| | } ntj} tddt|j| D} t| drtj} | dkr|S|rt| | |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 c3s|]}t|fVqdSrxr)rr(r@rZr[rF=szterms_gcd..z5Inequalities cannot be used with terms_gcd. Found: %sdeepFcsg|]}t|fqSrZrX)rrAr@rZr[rEszterms_gcd..rclearTrNr@cSsg|]\}}||qSrZrZ)rrrrZrZr[r_srs)rZ)!r!rMrlhsrhsrr&ris_AtomrFrYrppoprrbr1rr;r|rrrr<rfrr=rrrPrrrSZ as_coeff_Mul) rUrPrprrwrZrrqrrdenomrtermrZr@r[rsFC              rc Os|t|ddgzt|f||\}}Wn.tk rV}ztdd|W5d}~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 rrrarsN) rbr1rr;r<rar!rrS)rUrbrPrprrqrrWrZrZr[ramsrac Os|t|ddgzt|f||\}}Wn.tk rV}ztdd|W5d}~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 rrrcrsNr7) rbr1rr;r<rcrrrSr:rZrZr[rcsrcc Os^t|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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 rrersN)rbr1rr;r<rer3rZrZr[res rec Ost|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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) rrfrsN)rbr1rr;r<rfrrS)rUrPrprrqrrgrWrZrZr[rfs   rfc Os~t|dgz t||ff||\\}}}Wn.tk r\}ztdd|W5d}~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 rrhrN)rbr1r"r;r<rhrrSr9rZrZr[rhs  rhc Oszt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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] rrirsNcSsg|] }|qSrZrr8rZrZr[r'szdecompose..)rbr1rr;r<rirr:rZrZr[risric Ost|ddgzt|f||\}}Wn.tk rV}ztdd|W5d}~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] rrrmrsNr7cSsg|] }|qSrZrr8rZrZr[rEszsturm..)rbr1rr;r<rmrrr:rZrZr[rm,srmc Oszt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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)) == 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 rrnrsNcSsg|]\}}||fqSrZrrprZrZr[rtszgff_list..)rbr1rr;r<rnr)rUrPrprrqrrvrZrZr[rnJs rncOs tddS)z3Compute greatest factorial factorization of ``f``. zsymbolic falling factorialNr1rUrPrprZrZr[gffysrbc Ost|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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) rrrrsN) rbr1rr;r<rrrrrS) rUrPrprrqrr(rVrrZrZr[rrsrrc Ostt|dgzt|f||\}}Wn.tk rT}ztdd|W5d}~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 rrsrsN)rbr1rr;r<rsrrSr:rZrZr[rssrscCs&|dkrdd}ndd}t||dS)z&Sort a list of ``(expr, exp)`` pairs. rcSs.|\}}|jj}|t|t|jt|j|fSrxr_rurPrfrrvrexpr_rZrZr[rsz_sorted_factors..keycSs.|\}}|jj}t|t|j|t|j|fSrxrcrdrZrZr[rsr)r)rvmethodrrZrZr[_sorted_factorss rgcCstdd|DS)z*Multiply a list of ``(expr, exp)`` pairs. cSsg|]\}}||qSrZrrrUrrZrZr[rsz$_factors_product..)rrvrZrZr[_factors_productsrjc s tjg}ddt|D}|D]}|jsBt|trNt|rN||9}q$nV|jr|j tj kr|j \}|jrjr||9}q$|jr |fq$n |tj}zt ||\}}Wn2tk r} z | jfW5d} ~ XYq$Xt||d} | \} } | tjk rLjr$|| 9}n(| jr< | fn| | tjftjkrd| q$jrfdd| Dq$g} | D]8\}}|jr ||fn| ||fq t| fq$|dkrfdddd DD|fS) z.Helper function for :func:`_symbolic_factor`. cSs"g|]}t|dr|n|qS) _eval_factor)rrkrrrZrZr[rsz)_symbolic_factor_list..NZ_listcsg|]\}}||fqSrZrZrh)rerZr[rsrcs(g|] ttfddDfqS)c3s|]\}}|kr|VqdSrxrZ)rrUrrrZr[rFsz3_symbolic_factor_list...)rr)rrirmr[rscSsh|] \}}|qSrZrZ)rrrrZrZr[ sz(_symbolic_factor_list..)rr=r make_argsr-rMrris_PowbaseZExp1rpr%rr;r|rRrZ is_positiver' is_integerrSrj)r|rqrfrrpargrqrrrrYZ_coeffZ_factorsrrUrrZ)rervr[_symbolic_factor_listsX     "         rtcst|trFt|dr|Stt|dd\}}t|t|St|drl|jfdd|j DSt|dr| fdd|DS|Sd S) z%Helper function for :func:`_factor`. rkfraction)rurpcsg|]}t|qSrZ_symbolic_factorrrsrfrqrZr[rsz$_symbolic_factor..rScsg|]}t|qSrZrvrxryrZr[rsN) rMrrrkrtrDrrjrYrpr)r|rqrfrrvrZryr[rws    rwcCsNt|ddgt||}t|}t|ttfr>t|trJ|d}}nt|\}}t |||\}}t |||\} } | r|j st d|| ddi} || fD]:} t | D],\} \}}|jst|| \}}||f| | <qqt||}t| |} |jsdd|D}d d| D} || }|j s2||fS||| fSn t d|d S) z>Helper function for :func:`sqf_list` and :func:`factor_list`. fracrrsza polynomial expected, got %srTcSsg|]\}}||fqSrZrrhrZrZr[r<sz(_generic_factor_list..cSsg|]\}}||fqSrZrrhrZrZr[r=sN)rbr1rcr!rMrrNrDrOrtrzr8clonerrkrrgr)r|rPrprfrqZnumerr_rfprZfqZ_optrvrrUrrrrZrZr[_generic_factor_lists6         r}cCs<|dd}t|gt||}||d<tt|||S)z4Helper function for :func:`sqf` and :func:`factor`. ruT)r^rbr1rcrwr!)r|rPrprfrurqrZrZr[_generic_factorIs    r~csddlmd 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 - 2*sqrt(2)) >>> g Poly(x**3 + x**2 - 1/4*x - 1/4, x, domain='QQ') >>> r1 = simplify(1/r) >>> Poly(lc*r**3*(g.as_expr()).subs({x:x*r1}), x, domain='EX') == p True rsimplifyNc s@t|jdkr|jdjs"d|fS|}|}|p<|}|dd}fdd|D}t|dkr<|dr<|d|d}g}tt|D]2}||||d}|jsq<| |qd|} |jd} | |g} td|dD]"}| ||d| ||qt | }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``. rsrNcsg|] }|qSrZrZ)rcoeffxrrZr[rsz._try_rescale..r+) rurPr]r!r)rcrrrKr%r rN) rUf1rrQrZ rescale1_xZcoeffs1rrZ rescale_xrrrrZr[ _try_rescalezs0       z(to_rational_coeffs.._try_rescalec st|jdkr|jdjs"d|fS|}|p4|}|dd}|d}|jr|jst|j dddd\}}|j | |}| |}||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``. rsrNcSs |jdkSNTrJ)zrZrZr[rrz._try_translate..Tbinary) rurPr]r!rcris_AddrKrKrprYrj) rUrrrrratZnonratalphaf2rrZr[_try_translates     z*to_rational_coeffs.._try_translatecSsp|}d}|D]Z}t|D]J}t|j}dd|D}|sDqt|dkrTd}t|dkrdSqq|S)zS Return True if ``f`` is a sum with square roots but no other root FcSs,g|]$\}}|jr|jr|jdkr|jqS)r)rZ is_Rationalr)rrBZwxrZrZr[rs  zAto_rational_coeffs.._has_square_roots..rT)rr ror rvrminr)rbrZhas_sqrrrUrrZrZr[_has_square_rootss    z-to_rational_coeffs.._has_square_rootsrsr)N)N)sympy.simplify.simplifyrrrrc)rUrrrrrrZrr[to_rational_coeffsRs& "  rc Csddlm}t||dd}|}t|}|s2dS|\}}}} t| } |r|| d|||} |d|} g} | dddD],}| ||d||| i|dfqnF| d} g} | dddD](}| |d|||i|dfq| | 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 rrZEXrNrs) rrrNr!rrxrSr%r)rbrrp1rresrQrrQrVrvrr1rArrZrZr[_torational_factor_lists&    ,&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)]) rrfr}rarZrZr[rtsrtcOst|||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 rr)r~rarZrZr[rsrcOst|||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)]) rrrrarZrZr[rx!srx)rYc st|}|rtfdd}t||}i}|tt}|D]0}t|f}|jsX|jr8||kr8|||<q8||Szt |ddWSt k r} z"|j st |WYSt | W5d} ~ 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, exp >>> from sympy.abc import x, y >>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2 >>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I) >>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2)) >>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1) By default, factor deals with an expression as a whole: >>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1) If the ``deep`` flag is True then subexpressions will be factored: >>> factor(eq, deep=True) 2**((x + 1)**2) If the ``fraction`` flag is False then rational expressions will not be combined. By default it is True. >>> factor(5*x + 3*exp(2 - 7*x), deep=True) (5*x*exp(7*x) + 3*exp(2))*exp(-7*x) >>> factor(5*x + 3*exp(2 - 7*x), deep=True, fraction=False) 5*x + 3*exp(2)*exp(-7*x) See Also ======== sympy.ntheory.factor_.factorint cs$t|f}|js|jr |S|S)zS Factor, but avoid changing the expression when unable to. )ris_Mulrp)r|rr@rZr[ _try_factorys zfactor.._try_factorrrN) r!r$Zatomsrr rrrpxreplacer~r8rr) rUrYrPrprZpartialsZmuladdrbrmsgrZr@r[r3s"D    rc Cs4t|dsFz t|}Wntk r.gYSX|j||||||dSt|dd\}} t| jdkrhtt|D]\} } | j j || <qp|dk r| j |}|dkrt d|dk r| j |}|dk r| j |}t || j |||||d } g} | D]8\\}}}| j || j |}}| ||f|fq| 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)] rSr|r)rrsNrrz)r}r~rr r)rrNr7r{r"rurPr9rr_rrrrErr%)rrur}r~rr rrrrqrrr{rWr(rQrrZrZr[r{s>      r{cCs^z&t|}t|ts$|jjs$tdWn tk rFtd|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) generator must be a Symbolz,Cannot refine a root of %s, not a polynomial)r}rrr)rNrMr is_Symbolr8r7r)rUr(rQr}rrrrrZrZr[rs  rcCsZz*t|dd}t|ts(|jjs(tdWn tk rJtd|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 FZgreedyrz*Cannot count roots of %s, not a polynomialr)rNrMrrr8r7r)rUr~rrrZrZr[rs  rTcCsXz*t|dd}t|ts(|jjs(tdWn tk rJtd|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] Frrz1Cannot compute real roots of %s, not a polynomialr)rNrMrrr8r7r)rUrrrZrZr[r s   rrrcCs\z*t|dd}t|ts(|jjs(tdWn tk rJtd|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] Frrz6Cannot compute numerical roots of %s, not a polynomial)rrr)rNrMrrr8r7r)rUrrrrrZrZr[r(s   rc Osvt|gz2t|f||\}}t|ts<|jjs>> 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} rrrsN) rbr1rrMrNrrr8r;r<rr3rZrZr[rGs  rc Ost|gz2t|f||\}}t|ts<|jjs>> 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 rrrsN) rbr1rrMrNrrr8r;r<rrrS)rUrrPrprrqrrWrZrZr[res   r) _signsimpc sTddlm}ddlm}t|dgt|}|r:||}i}d|krR|d|d<t|tt fs|j szt|t szt|t s~|St |dd}|\}}nt|dkr|\}}t|trt|tr|j|d<|j|d <|dd|d<||}}n t|t r t |Std |dd lmzd|r8t|||ff||\} \} } | jst|tt fsv|WStj||fWSWn tk r} z|jr|st| |js|j rt!|j"fd d dd\} }dd|D}|j#t$|j#| f|WYSg}t%|}t&||D]R}t|tt t'frHq.z|(|t$|f|)Wnt*k r|YnXq.|+t,|WYSW5d} ~ XYnXd| $| } \}}|ddrd|kr| j-|d<t|tt fs| ||S||}}|dds.| ||fS| t|f||t|f||fSdS)a[ Cancel common factors in a rational function ``f``. Examples ======== >>> from sympy import cancel, sqrt, Symbol, together >>> from sympy.abc import x >>> A = Symbol('A', commutative=False) >>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2 Note: due to automatic distribution of Rationals, a sum divided by an integer will appear as a sum. To recover a rational form use `together` on the result: >>> cancel(x/2 + 1) x/2 + 1 >>> together(_) (x + 2)/2 r)signsimp)sringrT)radicalrrPrzunexpected argument: %sr#cs|jdko| Sr)rhasrr#rZr[rszcancel..rcSsg|] }t|qSrZ)rrlrZrZr[rszcancel..NrsF).rrsympy.polys.ringsrrbr1r!rMrr r-rrrrOrurNrPrrFrSrr&r$rr8Zngensrrr=rrrrKrprYrr#r/r%r%skiprdrrgr)rUrrPrprrrqrbrrrrrrncr*poterlrrZr#r[rs~             "  (  rc st|ddgz"t|gt|f||\}Wn.tk r`}ztdd|W5d}~XYnXj}d}jr|jr|j s d| id}dd l m }|jjj\} } t|D](\} } | jj} | | || <q|d|d d\} }fd d | D} tt|}|rhzd d | D|}}Wntk r\Yn 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) rrreducedrNFrTxringrscsg|]}tt|qSrZrNrhrgrrrrZr[r#szreduced..cSsg|] }|qSrZrrrZrZr[r(scSsg|] }|qSrZrrrZrZr[r/s)rbr1r"rjr;r<rrrrr{rrrrPr`rrr_rrrrNrhrgrr5rrS)rUrrPrprrrrr_ringrrrrr_Q_rrZrr[rs6"  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 :func:`~.solve_poly_system`. Examples ======== Example taken from [1]. >>> from sympy import groebner >>> from sympy.abc import x, y >>> F = [x*y - 2*y, 2*y**2 - x**2] >>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex') By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using the ``method`` flag or with the :func:`sympy.polys.polyconfig.setup` function. >>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)] >>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') References ========== 1. [Buchberger01]_ 2. [Cox97]_ ) GroebnerBasisrrPrprZrZr[r-4s3r-cOst|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_dimensionalrrZrZr[rjsrc@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|ddgzt|f||\}Wn2tk rZ}ztdt||W5d}~XYnXddlm}|jj j fdd|D}t |j d }fd d|D}| |S) z>Compute a reduced Groebner basis for a system of polynomials. rrfr-Nr)PolyRingcs g|]}|r|jqSrZ)rr_rrr)ringrZr[rsz)GroebnerBasis.__new__..rcsg|]}t|qSrZ)rNrhrrVrrZr[rs)rbr1r"r;r<rurrrPrr` _groebnerrf_new)rorrPrprrrrrZ)rqrr[rrs" zGroebnerBasis.__new__cCst|}t||_||_|Srx)r rrr_basis_options)robasisrbrvrZrZr[rs  zGroebnerBasis._newcCs$dd|jD}t|t|jjfS)Ncss|]}|VqdSrxr)rrbrZrZr[rFsz%GroebnerBasis.args..)rr rrP)r{rrZrZr[rpszGroebnerBasis.argscCsdd|jDS)NcSsg|] }|qSrZrrrZrZr[rsz'GroebnerBasis.exprs..)rrzrZrZr[r!szGroebnerBasis.exprscCs t|jSrx)rjrrzrZrZr[rszGroebnerBasis.polyscCs|jjSrx)rrPrzrZrZr[rPszGroebnerBasis.genscCs|jjSrx)rrrzrZrZr[rszGroebnerBasis.domaincCs|jjSrx)rr`rzrZrZr[r`szGroebnerBasis.ordercCs t|jSrx)rurrzrZrZr[__len__szGroebnerBasis.__len__cCs |jjrt|jSt|jSdSrx)rriterr!rzrZrZr[rSs zGroebnerBasis.__iter__cCs|jjr|j}n|j}||Srx)rrr!)r{itemrrZrZr[ __getitem__szGroebnerBasis.__getitem__cCst|jt|jfSrx)hashrrrrrzrZrZr[rszGroebnerBasis.__hash__cCsPt||jr$|j|jko"|j|jkSt|rH|jt|kpF|jt|kSdSdS)NF)rMrrrrJrrjr!r{rrZrZr[rs  zGroebnerBasis.__eq__cCs ||k SrxrZrrZrZr[rszGroebnerBasis.__ne__cCsTdd}tdgt|j}|jj}|jD] }|j|d}||r*||9}q*t|S)a{ Checks if the ideal generated by a Groebner basis is zero-dimensional. The algorithm checks if the set of monomials not divisible by the leading monomial of any element of ``F`` is bounded. References ========== David A. Cox, John B. Little, Donal O'Shea. Ideals, Varieties and Algorithms, 3rd edition, p. 230 cSsttt|dkSr)sumrr()monomialrZrZr[ single_varsz5GroebnerBasis.is_zero_dimensional..single_varrr)r.rurPrr`rr4ru)r{rr.r`rrrZrZr[rs   z!GroebnerBasis.is_zero_dimensionalc s|jj}t|}||kr |S|js.tdt|j}j}| |dddl m }|j j|\}}t |D](\} } | jj} || || <qzt|||} 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 ========== .. [1] J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering z?Cannot convert Groebner bases of ideals with positive dimension)rr`rrcsg|]}tt|qSrZrrrrZr[r.sz&GroebnerBasis.fglm..cSsg|]}|jdddqS)Tr@rs)r<rrZrZr[r1s)rr`r/rrdrjrrr{rrrrPrrr_rrr,rr) r{r`Z src_orderZ dst_orderrrrrrrrrrZrr[fglms0   zGroebnerBasis.fglmTcsRt||j}|gt|j}|jj}d}|rT|jrT|jsTd| id}ddl m }|j jj \}} t|D](\} }|jj}|||| <q~|d|dd\} } fdd | D} tt| } |r(zd d | D| } }Wntk rYn X| |} } jsFd 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 FrTrrrsNcsg|]}tt|qSrZrrrrZr[rgsz(GroebnerBasis.reduce..cSsg|] }|qSrZrrrZrZr[rlscSsg|] }|qSrZrrrZrZr[rss)rNrmrrjrrrrr{rrrrPr`rrr_rrrrhrgrr5rrS)r{r|rrrrrrrrrrrrrrZrr[r6s2  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 rsr)r)r{rrZrZr[containswszGroebnerBasis.containsN)T)rTrrrrrrrrrpr!rrPrr`rrSrrrrrrrrrZrZrZr[r|s6        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}}t|D]}gg}}t|D]b}|jrH|||q,|jr|jjr|jjr|jdkr||j| |jq,||q,|s||q|d}|ddD]}| |}q|rt|}|j r| |}n| t ||}||q|st ||} nZ|d} |ddD]}| |} q(|rnt|}|j r\| |} n| t ||} | j|ddS)NrrsrPrZ)r rorrr%rprqrerrrr-rNrmrrrF) r|rqrZ poly_termsr`rvZ poly_factorsrproductrW_polyrprZr[rsJ        zpoly.._polyrF)rbr1r!rkrNrcrrZrr[rs 4 rc Cs|dkrtd||f|d|dd}}|dkrFt|dd\}}t|t|f||f|}|dkr|t|td}n t||}|r|S|S)aCommon interface to the low-level polynomial generating functions in orthopolys and appellseqs. Parameters ========== n : int Index of the polynomial, which may or may not equal its degree. f : callable Low-level generating function to use. K : Domain or None Domain in which to perform the computations. If None, use the smallest field containing the rationals and the extra parameters of x (see below). name : str Name of an arbitrary individual polynomial in the sequence generated by f, only used in the error message for invalid n. x : seq The first element of this argument is the main variable of all polynomials in this sequence. Any further elements are extra parameters required by f. polys : bool, optional If True, return a Poly, otherwise (default) return an expression. rzCannot generate %s of index %srsNT)rr) rr'r0rrrwrrNrS) rrUKrrrheadtailrrZrZr[ named_polys r)r)N)N)FNNNFFF)NNFF)NN)T)rrT)r functoolsrroperatorrtypingrZ sympy.corerrr r Zsympy.core.basicr Zsympy.core.decoratorsr Zsympy.core.exprtoolsr rrZsympy.core.evalfrrrrrZsympy.core.functionrZsympy.core.mulrrZsympy.core.numbersrrrrZsympy.core.relationalrrZsympy.core.sortingrZsympy.core.symbolrr Zsympy.core.sympifyr!r"Zsympy.core.traversalr#r$Zsympy.logic.boolalgr%Z sympy.polysr&rbZsympy.polys.constructorr'Zsympy.polys.domainsr(r)r*Z!sympy.polys.domains.domainelementr+Zsympy.polys.fglmtoolsr,Zsympy.polys.groebnertoolsr-rZsympy.polys.monomialsr.Zsympy.polys.orderingsr/Zsympy.polys.polyclassesr0r1r2Zsympy.polys.polyerrorsr3r4r5r6r7r8r9r:r;r<r=Zsympy.polys.polyutilsr>r?r@rArBrCZsympy.polys.rationaltoolsrDZsympy.polys.rootisolationrEZsympy.utilitiesrFrGrHZsympy.utilities.exceptionsrIZsympy.utilities.iterablesrJrKrrZmpmath.libmp.libhyperrLr]rNrrrr"r r,r!r#r"r)r4r8rrrrrrrr rNrPrRrTrUrXr\rNr_rWr`rrarcrerfrhrirmrnrbrrrsrgrjrtrwr}r~rrrtrrxrr{rrrrrrrrrrrrrZrZrZr[s              4     "B] ( ^  : 4       " "    " & & 4 $  ( T 3 M 2 u    -    .  ! :, ,   b 7      +f ; 5  Q