Polynomials Manipulation Module Reference¶
Basic polynomial manipulation functions¶
-
sympy.polys.polytools.
poly
(expr, *gens, **args)[source]¶ 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')
-
sympy.polys.polytools.
poly_from_expr
(expr, *gens, **args)[source]¶ Construct a polynomial from an expression.
-
sympy.polys.polytools.
parallel_poly_from_expr
(exprs, *gens, **args)[source]¶ Construct polynomials from expressions.
-
sympy.polys.polytools.
degree
(f, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
degree_list
(f, *gens, **args)[source]¶ 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)
-
sympy.polys.polytools.
LC
(f, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
LM
(f, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
LT
(f, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
pdiv
(f, g, *gens, **args)[source]¶ Compute polynomial pseudo-division of
f
andg
.Examples
>>> from sympy import pdiv >>> from sympy.abc import x
>>> pdiv(x**2 + 1, 2*x - 4) (2*x + 4, 20)
-
sympy.polys.polytools.
prem
(f, g, *gens, **args)[source]¶ Compute polynomial pseudo-remainder of
f
andg
.Examples
>>> from sympy import prem >>> from sympy.abc import x
>>> prem(x**2 + 1, 2*x - 4) 20
-
sympy.polys.polytools.
pquo
(f, g, *gens, **args)[source]¶ Compute polynomial pseudo-quotient of
f
andg
.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
-
sympy.polys.polytools.
pexquo
(f, g, *gens, **args)[source]¶ Compute polynomial exact pseudo-quotient of
f
andg
.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
-
sympy.polys.polytools.
div
(f, g, *gens, **args)[source]¶ Compute polynomial division of
f
andg
.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)
-
sympy.polys.polytools.
rem
(f, g, *gens, **args)[source]¶ Compute polynomial remainder of
f
andg
.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
-
sympy.polys.polytools.
quo
(f, g, *gens, **args)[source]¶ Compute polynomial quotient of
f
andg
.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
-
sympy.polys.polytools.
exquo
(f, g, *gens, **args)[source]¶ Compute polynomial exact quotient of
f
andg
.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
-
sympy.polys.polytools.
half_gcdex
(f, g, *gens, **args)[source]¶ Half extended Euclidean algorithm of
f
andg
.Returns
(s, h)
such thath = gcd(f, g)
ands*f = h (mod g)
.Examples
>>> from sympy import half_gcdex >>> from sympy.abc import x
>>> half_gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (-x/5 + 3/5, x + 1)
-
sympy.polys.polytools.
gcdex
(f, g, *gens, **args)[source]¶ Extended Euclidean algorithm of
f
andg
.Returns
(s, t, h)
such thath = gcd(f, g)
ands*f + t*g = h
.Examples
>>> from sympy import gcdex >>> from sympy.abc import x
>>> gcdex(x**4 - 2*x**3 - 6*x**2 + 12*x + 15, x**3 + x**2 - 4*x - 4) (-x/5 + 3/5, x**2/5 - 6*x/5 + 2, x + 1)
-
sympy.polys.polytools.
invert
(f, g, *gens, **args)[source]¶ Invert
f
modulog
when possible.See also
sympy.core.numbers.mod_inverse
Examples
>>> from sympy import invert, S >>> from sympy.core.numbers import mod_inverse >>> from sympy.abc import x
>>> invert(x**2 - 1, 2*x - 1) -4/3
>>> invert(x**2 - 1, x - 1) Traceback (most recent call last): ... NotInvertible: zero divisor
For more efficient inversion of Rationals, use the
mod_inverse
function:>>> mod_inverse(3, 5) 2 >>> (S(2)/5).invert(S(7)/3) 5/2
-
sympy.polys.polytools.
subresultants
(f, g, *gens, **args)[source]¶ Compute subresultant PRS of
f
andg
.Examples
>>> from sympy import subresultants >>> from sympy.abc import x
>>> subresultants(x**2 + 1, x**2 - 1) [x**2 + 1, x**2 - 1, -2]
-
sympy.polys.polytools.
resultant
(f, g, *gens, **args)[source]¶ Compute resultant of
f
andg
.Examples
>>> from sympy import resultant >>> from sympy.abc import x
>>> resultant(x**2 + 1, x**2 - 1) 4
-
sympy.polys.polytools.
discriminant
(f, *gens, **args)[source]¶ Compute discriminant of
f
.Examples
>>> from sympy import discriminant >>> from sympy.abc import x
>>> discriminant(x**2 + 2*x + 3) -8
-
sympy.polys.dispersion.
dispersion
(p, q=None, *gens, **args)[source]¶ Compute 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:
\[\begin{split}\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\} \}\end{split}\]and for a single polynomial \(\operatorname{dis}(f) := \operatorname{dis}(f, f)\). Note that we make the definition \(\max\{\} := -\infty\).
See also
dispersionset
References
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
The maximum of an empty set is defined to be \(-\infty\) as seen in this example.
Computing the dispersion also works over field extensions:
>>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> 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]
-
sympy.polys.dispersion.
dispersionset
(p, q=None, *gens, **args)[source]¶ Compute 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:
\[\begin{split}\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\}\end{split}\]For a single polynomial one defines \(\operatorname{J}(f) := \operatorname{J}(f, f)\).
See also
dispersion
References
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<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> 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]
-
sympy.polys.polytools.
terms_gcd
(f, *gens, **args)[source]¶ Remove GCD of terms from
f
.If the
deep
flag is True, then the arguments off
will have terms_gcd applied to them.If a fraction is factored out of
f
andf
is an Add, then an unevaluated Mul will be returned so that automatic simplification does not redistribute it. The hintclear
, 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
-
sympy.polys.polytools.
cofactors
(f, g, *gens, **args)[source]¶ Compute GCD and cofactors of
f
andg
.Returns polynomials
(h, cff, cfg)
such thath = gcd(f, g)
, andcff = quo(f, h)
andcfg = quo(g, h)
are, so called, cofactors off
andg
.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)
-
sympy.polys.polytools.
gcd
(f, g=None, *gens, **args)[source]¶ Compute GCD of
f
andg
.Examples
>>> from sympy import gcd >>> from sympy.abc import x
>>> gcd(x**2 - 1, x**2 - 3*x + 2) x - 1
-
sympy.polys.polytools.
gcd_list
(seq, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
lcm
(f, g=None, *gens, **args)[source]¶ Compute LCM of
f
andg
.Examples
>>> from sympy import lcm >>> from sympy.abc import x
>>> lcm(x**2 - 1, x**2 - 3*x + 2) x**3 - 2*x**2 - x + 2
-
sympy.polys.polytools.
lcm_list
(seq, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
trunc
(f, p, *gens, **args)[source]¶ Reduce
f
modulo a constantp
.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
-
sympy.polys.polytools.
monic
(f, *gens, **args)[source]¶ Divide all coefficients of
f
byLC(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
-
sympy.polys.polytools.
content
(f, *gens, **args)[source]¶ Compute GCD of coefficients of
f
.Examples
>>> from sympy import content >>> from sympy.abc import x
>>> content(6*x**2 + 8*x + 12) 2
-
sympy.polys.polytools.
primitive
(f, *gens, **args)[source]¶ 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)
-
sympy.polys.polytools.
compose
(f, g, *gens, **args)[source]¶ Compute functional composition
f(g)
.Examples
>>> from sympy import compose >>> from sympy.abc import x
>>> compose(x**2 + x, x - 1) x**2 - x
-
sympy.polys.polytools.
decompose
(f, *gens, **args)[source]¶ 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]
-
sympy.polys.polytools.
sturm
(f, *gens, **args)[source]¶ 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]
-
sympy.polys.polytools.
gff_list
(f, *gens, **args)[source]¶ Compute a list of greatest factorial factors of
f
.Examples
>>> from sympy import gff_list, ff >>> from sympy.abc import x
>>> f = x**5 + 2*x**4 - x**3 - 2*x**2
>>> gff_list(f) [(x, 1), (x + 2, 4)]
>>> (ff(x, 1)*ff(x + 2, 4)).expand() == f True
>>> f = 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
>>> gff_list(f) [(x**3 + 7, 2), (x**2 + 5*x, 3)]
>>> ff(x**3 + 7, 2)*ff(x**2 + 5*x, 3) == f True
-
sympy.polys.polytools.
sqf_norm
(f, *gens, **args)[source]¶ Compute square-free norm of
f
.Returns
s
,f
,r
, such thatg(x) = f(x-sa)
andr(x) = Norm(g(x))
is a square-free polynomial overK
, wherea
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)
-
sympy.polys.polytools.
sqf_part
(f, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
sqf_list
(f, *gens, **args)[source]¶ 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)])
-
sympy.polys.polytools.
sqf
(f, *gens, **args)[source]¶ 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
-
sympy.polys.polytools.
factor_list
(f, *gens, **args)[source]¶ 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)])
-
sympy.polys.polytools.
factor
(f, *gens, **args)[source]¶ Compute the factorization of expression,
f
, into irreducibles. (To factor an integer into primes, usefactorint
.)There two modes implemented: symbolic and formal. If
f
is not an instance ofPoly
and generators are not specified, then the former mode is used. Otherwise, the formal mode is used.In symbolic mode,
factor()
will traverse the expression tree and factor its components without any prior expansion, unless an instance ofAdd
is encountered (in this case formal factorization is used). This wayfactor()
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
ordomain
.See also
Examples
>>> from sympy import factor, sqrt >>> from sympy.abc import x, y
>>> factor(2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y) 2*(x + y)*(x**2 + 1)**2
>>> factor(x**2 + 1) x**2 + 1 >>> factor(x**2 + 1, modulus=2) (x + 1)**2 >>> factor(x**2 + 1, gaussian=True) (x - I)*(x + I)
>>> factor(x**2 - 2, extension=sqrt(2)) (x - sqrt(2))*(x + sqrt(2))
>>> factor((x**2 - 1)/(x**2 + 4*x + 4)) (x - 1)*(x + 1)/(x + 2)**2 >>> factor((x**2 + 4*x + 4)**10000000*(x**2 + 1)) (x + 2)**20000000*(x**2 + 1)
By default, factor deals with an expression as a whole:
>>> eq = 2**(x**2 + 2*x + 1) >>> factor(eq) 2**(x**2 + 2*x + 1)
If the
deep
flag is True then subexpressions will be factored:>>> factor(eq, deep=True) 2**((x + 1)**2)
-
sympy.polys.polytools.
intervals
(F, all=False, eps=None, inf=None, sup=None, strict=False, fast=False, sqf=False)[source]¶ 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)]
-
sympy.polys.polytools.
refine_root
(f, s, t, eps=None, steps=None, fast=False, check_sqf=False)[source]¶ 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)
-
sympy.polys.polytools.
count_roots
(f, inf=None, sup=None)[source]¶ Return the number of roots of
f
in[inf, sup]
interval.If one of
inf
orsup
is complex, it will return the number of roots in the complex rectangle with corners atinf
andsup
.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
-
sympy.polys.polytools.
real_roots
(f, multiple=True)[source]¶ 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]
-
sympy.polys.polytools.
nroots
(f, n=15, maxsteps=50, cleanup=True)[source]¶ 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]
-
sympy.polys.polytools.
ground_roots
(f, *gens, **args)[source]¶ Compute roots of
f
by factorization in the ground domain.Examples
>>> from sympy import ground_roots >>> from sympy.abc import x
>>> ground_roots(x**6 - 4*x**4 + 4*x**3 - x**2) {0: 2, 1: 2}
-
sympy.polys.polytools.
nth_power_roots_poly
(f, n, *gens, **args)[source]¶ Construct a polynomial with n-th powers of roots of
f
.Examples
>>> from sympy import nth_power_roots_poly, factor, roots >>> from sympy.abc import x
>>> f = x**4 - x**2 + 1 >>> g = factor(nth_power_roots_poly(f, 2))
>>> g (x**2 - x + 1)**2
>>> R_f = [ (r**2).expand() for r in roots(f) ] >>> R_g = roots(g).keys()
>>> set(R_f) == set(R_g) True
-
sympy.polys.polytools.
cancel
(f, *gens, **args)[source]¶ Cancel common factors in a rational function
f
.Examples
>>> from sympy import cancel, sqrt, Symbol >>> from sympy.abc import x >>> A = Symbol('A', commutative=False)
>>> cancel((2*x**2 - 2)/(x**2 - 2*x + 1)) (2*x + 2)/(x - 1) >>> cancel((sqrt(3) + sqrt(15)*A)/(sqrt(2) + sqrt(10)*A)) sqrt(6)/2
-
sympy.polys.polytools.
reduced
(f, G, *gens, **args)[source]¶ Reduces a polynomial
f
modulo a set of polynomialsG
.Given a polynomial
f
and a set of polynomialsG = (g_1, ..., g_n)
, computes a set of quotientsq = (q_1, ..., q_n)
and the remainderr
such thatf = q_1*g_1 + ... + q_n*g_n + r
, wherer
vanishes orr
is a completely reduced polynomial with respect toG
.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)
-
sympy.polys.polytools.
groebner
(F, *gens, **args)[source]¶ 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 arelex
,grlex
andgrevlex
. If no order is specified, it defaults tolex
.For more information on Groebner bases, see the references and the docstring of \(solve_poly_system()\).
References
Examples
Example taken from [1].
>>> from sympy import groebner >>> from sympy.abc import x, y
>>> F = [x*y - 2*y, 2*y**2 - x**2]
>>> groebner(F, x, y, order='lex') GroebnerBasis([x**2 - 2*y**2, x*y - 2*y, y**3 - 2*y], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, order='grlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grlex') >>> groebner(F, x, y, order='grevlex') GroebnerBasis([y**3 - 2*y, x**2 - 2*y**2, x*y - 2*y], x, y, domain='ZZ', order='grevlex')
By default, an improved implementation of the Buchberger algorithm is used. Optionally, an implementation of the F5B algorithm can be used. The algorithm can be set using
method
flag or with thesetup()
function fromsympy.polys.polyconfig
:>>> F = [x**2 - x - 1, (2*x - 1) * y - (x**10 - (1 - x)**10)]
>>> groebner(F, x, y, method='buchberger') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex') >>> groebner(F, x, y, method='f5b') GroebnerBasis([x**2 - x - 1, y - 55], x, y, domain='ZZ', order='lex')
-
sympy.polys.polytools.
is_zero_dimensional
(F, *gens, **args)[source]¶ 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
-
class
sympy.polys.polytools.
Poly
[source]¶ Generic class for representing polynomial expressions.
-
EC
(f, order=None)[source]¶ 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
-
EM
(f, order=None)[source]¶ 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
-
ET
(f, order=None)[source]¶ 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)
-
LC
(f, order=None)[source]¶ 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
-
LM
(f, order=None)[source]¶ Returns the leading 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).LM() x**2*y**0
-
LT
(f, order=None)[source]¶ Returns the leading 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).LT() (x**2*y**0, 4)
-
TC
(f)[source]¶ 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
-
abs
(f)[source]¶ 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')
-
add
(f, g)[source]¶ Add two polynomials
f
andg
.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')
-
add_ground
(f, coeff)[source]¶ 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')
-
all_coeffs
(f)[source]¶ 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]
-
all_monoms
(f)[source]¶ Returns all monomials from a univariate polynomial
f
.See also
Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x - 1, x).all_monoms() [(3,), (2,), (1,), (0,)]
-
all_roots
(f, multiple=True, radicals=True)[source]¶ 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)]
-
all_terms
(f)[source]¶ 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)]
-
args
¶ Don’t mess up with the core.
Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).args (x**2 + 1,)
-
as_dict
(f, native=False, zero=False)[source]¶ 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}
-
as_expr
(f, *gens)[source]¶ 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
-
cancel
(f, g, include=False)[source]¶ 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'))
-
clear_denoms
(convert=False)[source]¶ 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'))
-
coeff_monomial
(f, monom)[source]¶ Returns the coefficient of
monom
inf
if there, else None.See also
nth
- more efficient query using exponents of the monomial’s generators
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)
-
coeffs
(f, order=None)[source]¶ Returns all non-zero coefficients from
f
in lex order.See also
Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**3 + 2*x + 3, x).coeffs() [1, 2, 3]
-
cofactors
(f, g)[source]¶ Returns the GCD of
f
andg
and their cofactors.Returns polynomials
(h, cff, cfg)
such thath = gcd(f, g)
, andcff = quo(f, h)
andcfg = quo(g, h)
are, so called, cofactors off
andg
.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'))
-
compose
(f, g)[source]¶ Computes the functional composition of
f
andg
.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')
-
content
(f)[source]¶ 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
-
count_roots
(f, inf=None, sup=None)[source]¶ 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
-
decompose
(f)[source]¶ 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')]
-
deflate
(f)[source]¶ Reduce degree of
f
by mappingx_i**m
toy_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'))
-
degree
(f, gen=0)[source]¶ Returns degree of
f
inx_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
-
degree_list
(f)[source]¶ 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)
-
diff
(f, *specs, **kwargs)[source]¶ 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')
-
discriminant
(f)[source]¶ Computes the discriminant of
f
.Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 2*x + 3, x).discriminant() -8
-
dispersion
(f, g=None)[source]¶ Compute 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:
\[\begin{split}\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\} \}\end{split}\]and for a single polynomial \(\operatorname{dis}(f) := \operatorname{dis}(f, f)\).
See also
References
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<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> 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]
-
dispersionset
(f, g=None)[source]¶ Compute 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:
\[\begin{split}\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\}\end{split}\]For a single polynomial one defines \(\operatorname{J}(f) := \operatorname{J}(f, f)\).
See also
References
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<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> 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]
-
div
(f, g, auto=True)[source]¶ Polynomial division with remainder of
f
byg
.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'))
-
domain
¶ Get the ground domain of
self
.
-
eject
(f, *gens)[source]¶ 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]')
-
eval
(x, a=None, auto=True)[source]¶ Evaluate
f
ata
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')
-
exclude
(f)[source]¶ 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')
-
exquo
(f, g, auto=True)[source]¶ Computes polynomial exact quotient of
f
byg
.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
-
exquo_ground
(f, coeff)[source]¶ 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
-
factor_list
(f)[source]¶ 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_list_include
(f)[source]¶ Returns a list of irreducible factors of
f
.Examples
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y
>>> Poly(f).factor_list_include() [(Poly(2*x + 2*y, x, y, domain='ZZ'), 1), (Poly(x**2 + 1, x, y, domain='ZZ'), 2)]
-
free_symbols
¶ Free symbols of a polynomial expression.
Examples
>>> from sympy import Poly >>> from sympy.abc import x, y
>>> Poly(x**2 + 1).free_symbols set([x]) >>> Poly(x**2 + y).free_symbols set([x, y]) >>> Poly(x**2 + y, x).free_symbols set([x, y])
-
free_symbols_in_domain
¶ 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 set([y])
-
gcd
(f, g)[source]¶ Returns the polynomial GCD of
f
andg
.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')
-
gcdex
(f, g, auto=True)[source]¶ Extended Euclidean algorithm of
f
andg
.Returns
(s, t, h)
such thath = gcd(f, g)
ands*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'))
-
gen
¶ Return the principal generator.
Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).gen x
-
get_modulus
(f)[source]¶ Get the modulus of
f
.Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, modulus=2).get_modulus() 2
-
gff_list
(f)[source]¶ 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)]
-
ground_roots
(f)[source]¶ 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}
-
half_gcdex
(f, g, auto=True)[source]¶ Half extended Euclidean algorithm of
f
andg
.Returns
(s, h)
such thath = gcd(f, g)
ands*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'))
-
has_only_gens
(f, *gens)[source]¶ Return
True
ifPoly(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
-
homogeneous_order
(f)[source]¶ 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 usePoly.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
-
homogenize
(f, s)[source]¶ 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
Poly.is_homogeneous()
. If you want not only to check if a polynomial is homogeneous but also compute its homogeneous order, then usePoly.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')
-
inject
(f, front=False)[source]¶ 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')
-
integrate
(*specs, **args)[source]¶ 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')
-
intervals
(f, all=False, eps=None, inf=None, sup=None, fast=False, sqf=False)[source]¶ Compute isolating intervals for roots of
f
.For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used.
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)]
References:
1. 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. 2. 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.
-
invert
(f, g, auto=True)[source]¶ Invert
f
modulog
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
-
is_cyclotomic
¶ Returns
True
iff
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
-
is_ground
¶ Returns
True
iff
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
-
is_homogeneous
¶ Returns
True
iff
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
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
-
is_irreducible
¶ Returns
True
iff
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
-
is_linear
¶ Returns
True
iff
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
-
is_monic
¶ Returns
True
if the leading coefficient off
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
-
is_monomial
¶ Returns
True
iff
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
-
is_multivariate
¶ Returns
True
iff
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
-
is_one
¶ Returns
True
iff
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
-
is_primitive
¶ Returns
True
if GCD of the coefficients off
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
-
is_quadratic
¶ Returns
True
iff
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
-
is_sqf
¶ Returns
True
iff
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
-
is_univariate
¶ Returns
True
iff
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
-
is_zero
¶ Returns
True
iff
is a zero polynomial.Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(0, x).is_zero True >>> Poly(1, x).is_zero False
-
l1_norm
(f)[source]¶ 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
-
lcm
(f, g)[source]¶ Returns polynomial LCM of
f
andg
.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')
-
length
(f)[source]¶ 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
-
lift
(f)[source]¶ 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')
-
ltrim
(f, gen)[source]¶ Remove dummy generators from the “left” 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')
-
max_norm
(f)[source]¶ 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
-
monic
(auto=True)[source]¶ 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')
-
monoms
(f, order=None)[source]¶ Returns all non-zero monomials from
f
in lex order.See also
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)]
-
mul
(f, g)[source]¶ Multiply two polynomials
f
andg
.Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> Poly(x**2 + 1, x).mul(Poly(x - 2, x)) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ')
>>> Poly(x**2 + 1, x)*Poly(x - 2, x) Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ')
-
mul_ground
(f, coeff)[source]¶ 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')
-
neg
(f)[source]¶ 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')
-
nroots
(f, n=15, maxsteps=50, cleanup=True)[source]¶ 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]
-
nth
(f, *N)[source]¶ Returns the
n
-th coefficient off
whereN
are the exponents of the generators in the term of interest.See also
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
-
nth_power_roots_poly
(f, n)[source]¶ 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')
-
one
¶ Return one polynomial with
self
‘s properties.
-
pdiv
(f, g)[source]¶ Polynomial pseudo-division of
f
byg
.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'))
-
per
(f, rep, gens=None, remove=None)[source]¶ 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')
-
pexquo
(f, g)[source]¶ Polynomial exact pseudo-quotient of
f
byg
.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
-
pow
(f, n)[source]¶ Raise
f
to a non-negative powern
.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')
-
pquo
(f, g)[source]¶ Polynomial pseudo-quotient of
f
byg
.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')
-
prem
(f, g)[source]¶ Polynomial pseudo-remainder of
f
byg
.- 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')
-
primitive
(f)[source]¶ 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'))
-
quo
(f, g, auto=True)[source]¶ Computes polynomial quotient of
f
byg
.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')
-
quo_ground
(f, coeff)[source]¶ 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')
-
rat_clear_denoms
(g)[source]¶ 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]')
-
real_roots
(f, multiple=True, radicals=True)[source]¶ 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)]
-
refine_root
(f, s, t, eps=None, steps=None, fast=False, check_sqf=False)[source]¶ 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)
-
rem
(f, g, auto=True)[source]¶ Computes the polynomial remainder of
f
byg
.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')
-
reorder
(f, *gens, **args)[source]¶ 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')
-
replace
(f, x, y=None)[source]¶ Replace
x
withy
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')
-
resultant
(f, g, includePRS=False)[source]¶ Computes the resultant of
f
andg
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
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')])
-
retract
(f, field=None)[source]¶ 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')
-
root
(f, index, radicals=True)[source]¶ 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)
-
set_modulus
(f, modulus)[source]¶ 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)
-
shift
(f, a)[source]¶ 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')
-
sqf_list
(f, all=False)[source]¶ Returns a list of square-free factors of
f
.Examples
>>> from sympy import Poly >>> from sympy.abc import x
>>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16
>>> Poly(f).sqf_list() (2, [(Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)])
>>> Poly(f).sqf_list(all=True) (2, [(Poly(1, x, domain='ZZ'), 1), (Poly(x + 1, x, domain='ZZ'), 2), (Poly(x + 2, x, domain='ZZ'), 3)])
-
sqf_list_include
(f, all=False)[source]¶ 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_norm
(f)[source]¶ Computes square-free norm of
f
.Returns
s
,f
,r
, such thatg(x) = f(x-sa)
andr(x) = Norm(g(x))
is a square-free polynomial overK
, wherea
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<sqrt(3)>') >>> r Poly(x**4 - 4*x**2 + 16, x, domain='QQ')
-
sqf_part
(f)[source]¶ 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')
-
sqr
(f)[source]¶ 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')
-
sturm
(auto=True)[source]¶ 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')]
-
sub
(f, g)[source]¶ Subtract two polynomials
f
andg
.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_ground
(f, coeff)[source]¶ 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')
-
subresultants
(f, g)[source]¶ Computes the subresultant PRS of
f
andg
.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')]
-
terms
(f, order=None)[source]¶ Returns all non-zero terms from
f
in lex order.See also
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)]
-
terms_gcd
(f)[source]¶ 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'))
-
termwise
(f, func, *gens, **args)[source]¶ 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')
-
to_exact
(f)[source]¶ 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_field
(f)[source]¶ 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')
-
to_ring
(f)[source]¶ 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')
-
total_degree
(f)[source]¶ 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
-
trunc
(f, p)[source]¶ Reduce
f
modulo a constantp
.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')
-
unify
(f, g)[source]¶ Make
f
andg
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')
-
unit
¶ Return unit polynomial with
self
‘s properties.
-
zero
¶ Return zero polynomial with
self
‘s properties.
-
-
class
sympy.polys.polytools.
PurePoly
[source]¶ Class for representing pure polynomials.
-
free_symbols
¶ 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 set([y])
-
-
class
sympy.polys.polytools.
GroebnerBasis
[source]¶ Represents a reduced Groebner basis.
-
contains
(poly)[source]¶ Check if
poly
belongs the ideal generated byself
.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
-
fglm
(order)[source]¶ 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.
References
J.C. Faugere, P. Gianni, D. Lazard, T. Mora (1994). Efficient Computation of Zero-dimensional Groebner Bases by Change of Ordering
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]
-
is_zero_dimensional
¶ 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
-
reduce
(expr, auto=True)[source]¶ Reduces a polynomial modulo a Groebner basis.
Given a polynomial
f
and a set of polynomialsG = (g_1, ..., g_n)
, computes a set of quotientsq = (q_1, ..., q_n)
and the remainderr
such thatf = q_1*f_1 + ... + q_n*f_n + r
, wherer
vanishes orr
is a completely reduced polynomial with respect toG
.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
-
Extra polynomial manipulation functions¶
-
sympy.polys.polyfuncs.
symmetrize
(F, *gens, **args)[source]¶ Rewrite a polynomial in terms of elementary symmetric polynomials.
A symmetric polynomial is a multivariate polynomial that remains invariant under any variable permutation, i.e., if
f = f(x_1, x_2, ..., x_n)
, thenf = f(x_{i_1}, x_{i_2}, ..., x_{i_n})
, where(i_1, i_2, ..., i_n)
is a permutation of(1, 2, ..., n)
(an element of the groupS_n
).Returns a tuple of symmetric polynomials
(f1, f2, ..., fn)
such thatf = f1 + f2 + ... + fn
.Examples
>>> from sympy.polys.polyfuncs import symmetrize >>> from sympy.abc import x, y
>>> symmetrize(x**2 + y**2) (-2*x*y + (x + y)**2, 0)
>>> symmetrize(x**2 + y**2, formal=True) (s1**2 - 2*s2, 0, [(s1, x + y), (s2, x*y)])
>>> symmetrize(x**2 - y**2) (-2*x*y + (x + y)**2, -2*y**2)
>>> symmetrize(x**2 - y**2, formal=True) (s1**2 - 2*s2, -2*y**2, [(s1, x + y), (s2, x*y)])
-
sympy.polys.polyfuncs.
horner
(f, *gens, **args)[source]¶ Rewrite a polynomial in Horner form.
Among other applications, evaluation of a polynomial at a point is optimal when it is applied using the Horner scheme ([1]).
References
[1] - http://en.wikipedia.org/wiki/Horner_scheme
Examples
>>> from sympy.polys.polyfuncs import horner >>> from sympy.abc import x, y, a, b, c, d, e
>>> horner(9*x**4 + 8*x**3 + 7*x**2 + 6*x + 5) x*(x*(x*(9*x + 8) + 7) + 6) + 5
>>> horner(a*x**4 + b*x**3 + c*x**2 + d*x + e) e + x*(d + x*(c + x*(a*x + b)))
>>> f = 4*x**2*y**2 + 2*x**2*y + 2*x*y**2 + x*y
>>> horner(f, wrt=x) x*(x*y*(4*y + 2) + y*(2*y + 1))
>>> horner(f, wrt=y) y*(x*y*(4*x + 2) + x*(2*x + 1))
-
sympy.polys.polyfuncs.
interpolate
(data, x)[source]¶ Construct an interpolating polynomial for the data points.
Examples
>>> from sympy.polys.polyfuncs import interpolate >>> from sympy.abc import x
A list is interpreted as though it were paired with a range starting from 1:
>>> interpolate([1, 4, 9, 16], x) x**2
This can be made explicit by giving a list of coordinates:
>>> interpolate([(1, 1), (2, 4), (3, 9)], x) x**2
The (x, y) coordinates can also be given as keys and values of a dictionary (and the points need not be equispaced):
>>> interpolate([(-1, 2), (1, 2), (2, 5)], x) x**2 + 1 >>> interpolate({-1: 2, 1: 2, 2: 5}, x) x**2 + 1
-
sympy.polys.polyfuncs.
viete
(f, roots=None, *gens, **args)[source]¶ Generate Viete’s formulas for
f
.Examples
>>> from sympy.polys.polyfuncs import viete >>> from sympy import symbols
>>> x, a, b, c, r1, r2 = symbols('x,a:c,r1:3')
>>> viete(a*x**2 + b*x + c, [r1, r2], x) [(r1 + r2, -b/a), (r1*r2, c/a)]
Domain constructors¶
Algebraic number fields¶
-
sympy.polys.numberfields.
minimal_polynomial
(ex, x=None, **args)[source]¶ Computes the minimal polynomial of an algebraic element.
Parameters: ex : algebraic element expression
x : independent variable of the minimal polynomial
Notes
By default
compose=True
, the minimal polynomial of the subexpressions ofex
are computed, then the arithmetic operations on them are performed using the resultant and factorization. Ifcompose=False
, a bottom-up algorithm is used withgroebner
. The default algorithm stalls less frequently.If no ground domain is given, it will be generated automatically from the expression.
Examples
>>> from sympy import minimal_polynomial, sqrt, solve, QQ >>> from sympy.abc import x, y
>>> minimal_polynomial(sqrt(2), x) x**2 - 2 >>> minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2))) x - sqrt(2) >>> minimal_polynomial(sqrt(2) + sqrt(3), x) x**4 - 10*x**2 + 1 >>> minimal_polynomial(solve(x**3 + x + 3)[0], x) x**3 + x + 3 >>> minimal_polynomial(sqrt(y), x) x**2 - y
Options
compose : if
True
_minpoly_compose
is used, ifFalse
thegroebner
algorithm polys : ifTrue
returns aPoly
object domain : ground domain
-
sympy.polys.numberfields.
minpoly
(ex, x=None, **args)¶ Computes the minimal polynomial of an algebraic element.
Parameters: ex : algebraic element expression
x : independent variable of the minimal polynomial
Notes
By default
compose=True
, the minimal polynomial of the subexpressions ofex
are computed, then the arithmetic operations on them are performed using the resultant and factorization. Ifcompose=False
, a bottom-up algorithm is used withgroebner
. The default algorithm stalls less frequently.If no ground domain is given, it will be generated automatically from the expression.
Examples
>>> from sympy import minimal_polynomial, sqrt, solve, QQ >>> from sympy.abc import x, y
>>> minimal_polynomial(sqrt(2), x) x**2 - 2 >>> minimal_polynomial(sqrt(2), x, domain=QQ.algebraic_field(sqrt(2))) x - sqrt(2) >>> minimal_polynomial(sqrt(2) + sqrt(3), x) x**4 - 10*x**2 + 1 >>> minimal_polynomial(solve(x**3 + x + 3)[0], x) x**3 + x + 3 >>> minimal_polynomial(sqrt(y), x) x**2 - y
Options
compose : if
True
_minpoly_compose
is used, ifFalse
thegroebner
algorithm polys : ifTrue
returns aPoly
object domain : ground domain
-
sympy.polys.numberfields.
primitive_element
(extension, x=None, **args)[source]¶ Construct a common number field for all extensions.
-
sympy.polys.numberfields.
field_isomorphism
(a, b, **args)[source]¶ Construct an isomorphism between two number fields.
-
sympy.polys.numberfields.
to_number_field
(extension, theta=None, **args)[source]¶ Express \(extension\) in the field generated by \(theta\).
-
sympy.polys.numberfields.
isolate
(alg, eps=None, fast=False)[source]¶ Give a rational isolating interval for an algebraic number.
Monomials encoded as tuples¶
-
class
sympy.polys.monomials.
Monomial
(monom, gens=None)[source]¶ Class representing a monomial, i.e. a product of powers.
-
sympy.polys.monomials.
itermonomials
(variables, degree)[source]¶ Generate a set of monomials of the given total degree or less.
Given a set of variables \(V\) and a total degree \(N\) generate a set of monomials of degree at most \(N\). The total number of monomials is huge and is given by the following formula:
\[\frac{(\#V + N)!}{\#V! N!}\]For example if we would like to generate a dense polynomial of a total degree \(N = 50\) in 5 variables, assuming that exponents and all of coefficients are 32-bit long and stored in an array we would need almost 80 GiB of memory! Fortunately most polynomials, that we will encounter, are sparse.
Examples
Consider monomials in variables \(x\) and \(y\):
>>> from sympy.polys.monomials import itermonomials >>> from sympy.polys.orderings import monomial_key >>> from sympy.abc import x, y >>> sorted(itermonomials([x, y], 2), key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2] >>> sorted(itermonomials([x, y], 3), key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2, x**3, x**2*y, x*y**2, y**3]
-
sympy.polys.monomials.
monomial_count
(V, N)[source]¶ Computes the number of monomials.
The number of monomials is given by the following formula:
\[\frac{(\#V + N)!}{\#V! N!}\]where \(N\) is a total degree and \(V\) is a set of variables.
Examples
>>> from sympy.polys.monomials import itermonomials, monomial_count >>> from sympy.polys.orderings import monomial_key >>> from sympy.abc import x, y
>>> monomial_count(2, 2) 6
>>> M = itermonomials([x, y], 2)
>>> sorted(M, key=monomial_key('grlex', [y, x])) [1, x, y, x**2, x*y, y**2] >>> len(M) 6
Orderings of monomials¶
Formal manipulation of roots of polynomials¶
-
sympy.polys.rootoftools.
rootof
(f, x, index=None, radicals=True, expand=True)[source]¶ An indexed root of a univariate polynomial.
Returns either a
ComplexRootOf
object or an explicit expression involving radicals.Parameters: f : Expr
Univariate polynomial.
x : Symbol, optional
Generator for
f
.index : int or Integer
radicals : bool
Return a radical expression if possible.
expand : bool
Expand
f
.
-
class
sympy.polys.rootoftools.
RootOf
[source]¶ Represents a root of a univariate polynomial.
Base class for roots of different kinds of polynomials. Only complex roots are currently supported.
Symbolic root-finding algorithms¶
-
sympy.polys.polyroots.
roots
(f, *gens, **flags)[source]¶ Computes symbolic roots of a univariate polynomial.
Given a univariate polynomial f with symbolic coefficients (or a list of the polynomial’s coefficients), returns a dictionary with its roots and their multiplicities.
Only roots expressible via radicals will be returned. To get a complete set of roots use RootOf class or numerical methods instead. By default cubic and quartic formulas are used in the algorithm. To disable them because of unreadable output set
cubics=False
orquartics=False
respectively. If cubic roots are real but are expressed in terms of complex numbers (casus irreducibilis [1]) thetrig
flag can be set to True to have the solutions returned in terms of cosine and inverse cosine functions.To get roots from a specific domain set the
filter
flag with one of the following specifiers: Z, Q, R, I, C. By default all roots are returned (this is equivalent to settingfilter='C'
).By default a dictionary is returned giving a compact result in case of multiple roots. However to get a list containing all those roots set the
multiple
flag to True; the list will have identical roots appearing next to each other in the result. (For a given Poly, the all_roots method will give the roots in sorted numerical order.)References
Examples
>>> from sympy import Poly, roots >>> from sympy.abc import x, y
>>> roots(x**2 - 1, x) {-1: 1, 1: 1}
>>> p = Poly(x**2-1, x) >>> roots(p) {-1: 1, 1: 1}
>>> p = Poly(x**2-y, x, y)
>>> roots(Poly(p, x)) {-sqrt(y): 1, sqrt(y): 1}
>>> roots(x**2 - y, x) {-sqrt(y): 1, sqrt(y): 1}
>>> roots([1, 0, -1]) {-1: 1, 1: 1}
Special polynomials¶
-
sympy.polys.specialpolys.
swinnerton_dyer_poly
(n, x=None, **args)[source]¶ Generates n-th Swinnerton-Dyer polynomial in \(x\).
-
sympy.polys.specialpolys.
interpolating_poly
(n, x, X='x', Y='y')[source]¶ Construct Lagrange interpolating polynomial for
n
data points.
-
sympy.polys.specialpolys.
cyclotomic_poly
(n, x=None, **args)[source]¶ Generates cyclotomic polynomial of order \(n\) in \(x\).
Orthogonal polynomials¶
-
sympy.polys.orthopolys.
chebyshevt_poly
(n, x=None, **args)[source]¶ Generates Chebyshev polynomial of the first kind of degree \(n\) in \(x\).
-
sympy.polys.orthopolys.
chebyshevu_poly
(n, x=None, **args)[source]¶ Generates Chebyshev polynomial of the second kind of degree \(n\) in \(x\).
-
sympy.polys.orthopolys.
gegenbauer_poly
(n, a, x=None, **args)[source]¶ Generates Gegenbauer polynomial of degree \(n\) in \(x\).
-
sympy.polys.orthopolys.
hermite_poly
(n, x=None, **args)[source]¶ Generates Hermite polynomial of degree \(n\) in \(x\).
-
sympy.polys.orthopolys.
jacobi_poly
(n, a, b, x=None, **args)[source]¶ Generates Jacobi polynomial of degree \(n\) in \(x\).
Manipulation of rational functions¶
-
sympy.polys.rationaltools.
together
(expr, deep=False)[source]¶ Denest and combine rational expressions using symbolic methods.
This function takes an expression or a container of expressions and puts it (them) together by denesting and combining rational subexpressions. No heroic measures are taken to minimize degree of the resulting numerator and denominator. To obtain completely reduced expression use
cancel()
. However,together()
can preserve as much as possible of the structure of the input expression in the output (no expansion is performed).A wide variety of objects can be put together including lists, tuples, sets, relational objects, integrals and others. It is also possible to transform interior of function applications, by setting
deep
flag toTrue
.By definition,
together()
is a complement toapart()
, soapart(together(expr))
should return expr unchanged. Note however, thattogether()
uses only symbolic methods, so it might be necessary to usecancel()
to perform algebraic simplification and minimise degree of the numerator and denominator.Examples
>>> from sympy import together, exp >>> from sympy.abc import x, y, z
>>> together(1/x + 1/y) (x + y)/(x*y) >>> together(1/x + 1/y + 1/z) (x*y + x*z + y*z)/(x*y*z)
>>> together(1/(x*y) + 1/y**2) (x + y)/(x*y**2)
>>> together(1/(1 + 1/x) + 1/(1 + 1/y)) (x*(y + 1) + y*(x + 1))/((x + 1)*(y + 1))
>>> together(exp(1/x + 1/y)) exp(1/y + 1/x) >>> together(exp(1/x + 1/y), deep=True) exp((x + y)/(x*y))
>>> together(1/exp(x) + 1/(x*exp(x))) (x + 1)*exp(-x)/x
>>> together(1/exp(2*x) + 1/(x*exp(3*x))) (x*exp(x) + 1)*exp(-3*x)/x
Partial fraction decomposition¶
-
sympy.polys.partfrac.
apart
(expr, *args, **kwargs)[source]¶ Compute partial fraction decomposition of a rational function.
Given a rational function
f
, computes the partial fraction decomposition off
. Two algorithms are available: One is based on the undertermined coefficients method, the other is Bronstein’s full partial fraction decomposition algorithm.The undetermined coefficients method (selected by
full=False
) uses polynomial factorization (and therefore accepts the same options as factor) for the denominator. Per default it works over the rational numbers, therefore decomposition of denominators with non-rational roots (e.g. irrational, complex roots) is not supported by default (see options of factor).Bronstein’s algorithm can be selected by using
full=True
and allows a decomposition of denominators with non-rational roots. A human-readable result can be obtained viadoit()
(see examples below).See also
Examples
>>> from sympy.polys.partfrac import apart >>> from sympy.abc import x, y
By default, using the undetermined coefficients method:
>>> apart(y/(x + 2)/(x + 1), x) -y/(x + 2) + y/(x + 1)
The undetermined coefficients method does not provide a result when the denominators roots are not rational:
>>> apart(y/(x**2 + x + 1), x) y/(x**2 + x + 1)
You can choose Bronstein’s algorithm by setting
full=True
:>>> apart(y/(x**2 + x + 1), x, full=True) RootSum(_w**2 + _w + 1, Lambda(_a, (-2*_a*y/3 - y/3)/(-_a + x)))
Calling
doit()
yields a human-readable result:>>> apart(y/(x**2 + x + 1), x, full=True).doit() (-y/3 - 2*y*(-1/2 - sqrt(3)*I/2)/3)/(x + 1/2 + sqrt(3)*I/2) + (-y/3 - 2*y*(-1/2 + sqrt(3)*I/2)/3)/(x + 1/2 - sqrt(3)*I/2)
-
sympy.polys.partfrac.
apart_list
(f, x=None, dummies=None, **options)[source]¶ Compute partial fraction decomposition of a rational function and return the result in structured form.
Given a rational function
f
compute the partial fraction decomposition off
. Only Bronstein’s full partial fraction decomposition algorithm is supported by this method. The return value is highly structured and perfectly suited for further algorithmic treatment rather than being human-readable. The function returns a tuple holding three elements:- The first item is the common coefficient, free of the variable \(x\) used for decomposition. (It is an element of the base field \(K\).)
- The second item is the polynomial part of the decomposition. This can be the zero polynomial. (It is an element of \(K[x]\).)
- The third part itself is a list of quadruples. Each quadruple
has the following elements in this order:
- The (not necessarily irreducible) polynomial \(D\) whose roots \(w_i\) appear
in the linear denominator of a bunch of related fraction terms. (This item
can also be a list of explicit roots. However, at the moment
apart_list
never returns a result this way, but the relatedassemble_partfrac_list
function accepts this format as input.) - The numerator of the fraction, written as a function of the root \(w\)
- The linear denominator of the fraction excluding its power exponent, written as a function of the root \(w\).
- The power to which the denominator has to be raised.
- The (not necessarily irreducible) polynomial \(D\) whose roots \(w_i\) appear
in the linear denominator of a bunch of related fraction terms. (This item
can also be a list of explicit roots. However, at the moment
On can always rebuild a plain expression by using the function
assemble_partfrac_list
.See also
References
Examples
A first example:
>>> from sympy.polys.partfrac import apart_list, assemble_partfrac_list >>> from sympy.abc import x, t
>>> f = (2*x**3 - 2*x) / (x**2 - 2*x + 1) >>> pfd = apart_list(f) >>> pfd (1, Poly(2*x + 4, x, domain='ZZ'), [(Poly(_w - 1, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) 2*x + 4 + 4/(x - 1)
Second example:
>>> f = (-2*x - 2*x**2) / (3*x**2 - 6*x) >>> pfd = apart_list(f) >>> pfd (-1, Poly(2/3, x, domain='QQ'), [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 2), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) -2/3 - 2/(x - 2)
Another example, showing symbolic parameters:
>>> pfd = apart_list(t/(x**2 + x + t), x) >>> pfd (1, Poly(0, x, domain='ZZ[t]'), [(Poly(_w**2 + _w + t, _w, domain='ZZ[t]'), Lambda(_a, -2*_a*t/(4*t - 1) - t/(4*t - 1)), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) RootSum(_w**2 + _w + t, Lambda(_a, (-2*_a*t/(4*t - 1) - t/(4*t - 1))/(-_a + x)))
This example is taken from Bronstein’s original paper:
>>> f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2) >>> pfd = apart_list(f) >>> pfd (1, Poly(0, x, domain='ZZ'), [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1), (Poly(_w**2 - 1, _w, domain='ZZ'), Lambda(_a, -3*_a - 6), Lambda(_a, -_a + x), 2), (Poly(_w + 1, _w, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
-
sympy.polys.partfrac.
assemble_partfrac_list
(partial_list)[source]¶ Reassemble a full partial fraction decomposition from a structured result obtained by the function
apart_list
.See also
Examples
This example is taken from Bronstein’s original paper:
>>> from sympy.polys.partfrac import apart_list, assemble_partfrac_list >>> from sympy.abc import x, y
>>> f = 36 / (x**5 - 2*x**4 - 2*x**3 + 4*x**2 + x - 2) >>> pfd = apart_list(f) >>> pfd (1, Poly(0, x, domain='ZZ'), [(Poly(_w - 2, _w, domain='ZZ'), Lambda(_a, 4), Lambda(_a, -_a + x), 1), (Poly(_w**2 - 1, _w, domain='ZZ'), Lambda(_a, -3*_a - 6), Lambda(_a, -_a + x), 2), (Poly(_w + 1, _w, domain='ZZ'), Lambda(_a, -4), Lambda(_a, -_a + x), 1)])
>>> assemble_partfrac_list(pfd) -4/(x + 1) - 3/(x + 1)**2 - 9/(x - 1)**2 + 4/(x - 2)
If we happen to know some roots we can provide them easily inside the structure:
>>> pfd = apart_list(2/(x**2-2)) >>> pfd (1, Poly(0, x, domain='ZZ'), [(Poly(_w**2 - 2, _w, domain='ZZ'), Lambda(_a, _a/2), Lambda(_a, -_a + x), 1)])
>>> pfda = assemble_partfrac_list(pfd) >>> pfda RootSum(_w**2 - 2, Lambda(_a, _a/(-_a + x)))/2
>>> pfda.doit() -sqrt(2)/(2*(x + sqrt(2))) + sqrt(2)/(2*(x - sqrt(2)))
>>> from sympy import Dummy, Poly, Lambda, sqrt >>> a = Dummy("a") >>> pfd = (1, Poly(0, x, domain='ZZ'), [([sqrt(2),-sqrt(2)], Lambda(a, a/2), Lambda(a, -a + x), 1)])
>>> assemble_partfrac_list(pfd) -sqrt(2)/(2*(x + sqrt(2))) + sqrt(2)/(2*(x - sqrt(2)))
Dispersion of Polynomials¶
-
sympy.polys.dispersion.
dispersionset
(p, q=None, *gens, **args)[source] Compute 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:
\[\begin{split}\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\}\end{split}\]For a single polynomial one defines \(\operatorname{J}(f) := \operatorname{J}(f, f)\).
See also
References
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<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> 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]
-
sympy.polys.dispersion.
dispersion
(p, q=None, *gens, **args)[source] Compute 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:
\[\begin{split}\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\} \}\end{split}\]and for a single polynomial \(\operatorname{dis}(f) := \operatorname{dis}(f, f)\). Note that we make the definition \(\max\{\} := -\infty\).
See also
References
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
The maximum of an empty set is defined to be \(-\infty\) as seen in this example.
Computing the dispersion also works over field extensions:
>>> from sympy import sqrt >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>') >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>') >>> 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]