You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7426 lines
190 KiB
7426 lines
190 KiB
"""User-friendly public interface to polynomial functions. """
|
|
|
|
|
|
from functools import wraps, reduce
|
|
from operator import mul
|
|
from typing import Optional
|
|
|
|
from sympy.core import (
|
|
S, Expr, Add, Tuple
|
|
)
|
|
from sympy.core.basic import Basic
|
|
from sympy.core.decorators import _sympifyit
|
|
from sympy.core.exprtools import Factors, factor_nc, factor_terms
|
|
from sympy.core.evalf import (
|
|
pure_complex, evalf, fastlog, _evalf_with_bounded_error, quad_to_mpmath)
|
|
from sympy.core.function import Derivative
|
|
from sympy.core.mul import Mul, _keep_coeff
|
|
from sympy.core.numbers import ilcm, I, Integer, equal_valued
|
|
from sympy.core.relational import Relational, Equality
|
|
from sympy.core.sorting import ordered
|
|
from sympy.core.symbol import Dummy, Symbol
|
|
from sympy.core.sympify import sympify, _sympify
|
|
from sympy.core.traversal import preorder_traversal, bottom_up
|
|
from sympy.logic.boolalg import BooleanAtom
|
|
from sympy.polys import polyoptions as options
|
|
from sympy.polys.constructor import construct_domain
|
|
from sympy.polys.domains import FF, QQ, ZZ
|
|
from sympy.polys.domains.domainelement import DomainElement
|
|
from sympy.polys.fglmtools import matrix_fglm
|
|
from sympy.polys.groebnertools import groebner as _groebner
|
|
from sympy.polys.monomials import Monomial
|
|
from sympy.polys.orderings import monomial_key
|
|
from sympy.polys.polyclasses import DMP, DMF, ANP
|
|
from sympy.polys.polyerrors import (
|
|
OperationNotSupported, DomainError,
|
|
CoercionFailed, UnificationFailed,
|
|
GeneratorsNeeded, PolynomialError,
|
|
MultivariatePolynomialError,
|
|
ExactQuotientFailed,
|
|
PolificationFailed,
|
|
ComputationFailed,
|
|
GeneratorsError,
|
|
)
|
|
from sympy.polys.polyutils import (
|
|
basic_from_dict,
|
|
_sort_gens,
|
|
_unify_gens,
|
|
_dict_reorder,
|
|
_dict_from_expr,
|
|
_parallel_dict_from_expr,
|
|
)
|
|
from sympy.polys.rationaltools import together
|
|
from sympy.polys.rootisolation import dup_isolate_real_roots_list
|
|
from sympy.utilities import group, public, filldedent
|
|
from sympy.utilities.exceptions import sympy_deprecation_warning
|
|
from sympy.utilities.iterables import iterable, sift
|
|
|
|
|
|
# Required to avoid errors
|
|
import sympy.polys
|
|
|
|
import mpmath
|
|
from mpmath.libmp.libhyper import NoConvergence
|
|
|
|
|
|
|
|
def _polifyit(func):
|
|
@wraps(func)
|
|
def wrapper(f, g):
|
|
g = _sympify(g)
|
|
if isinstance(g, Poly):
|
|
return func(f, g)
|
|
elif isinstance(g, Expr):
|
|
try:
|
|
g = f.from_expr(g, *f.gens)
|
|
except PolynomialError:
|
|
if g.is_Matrix:
|
|
return NotImplemented
|
|
expr_method = getattr(f.as_expr(), func.__name__)
|
|
result = expr_method(g)
|
|
if result is not NotImplemented:
|
|
sympy_deprecation_warning(
|
|
"""
|
|
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().
|
|
""",
|
|
deprecated_since_version="1.6",
|
|
active_deprecations_target="deprecated-poly-nonpoly-binary-operations",
|
|
)
|
|
return result
|
|
else:
|
|
return func(f, g)
|
|
else:
|
|
return NotImplemented
|
|
return wrapper
|
|
|
|
|
|
|
|
@public
|
|
class Poly(Basic):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
|
|
__slots__ = ('rep', 'gens')
|
|
|
|
is_commutative = True
|
|
is_Poly = True
|
|
_op_priority = 10.001
|
|
|
|
def __new__(cls, rep, *gens, **args):
|
|
"""Create a new polynomial instance out of something useful. """
|
|
opt = options.build_options(gens, args)
|
|
|
|
if 'order' in opt:
|
|
raise NotImplementedError("'order' keyword is not implemented yet")
|
|
|
|
if isinstance(rep, (DMP, DMF, ANP, DomainElement)):
|
|
return cls._from_domain_element(rep, opt)
|
|
elif iterable(rep, exclude=str):
|
|
if isinstance(rep, dict):
|
|
return cls._from_dict(rep, opt)
|
|
else:
|
|
return cls._from_list(list(rep), opt)
|
|
else:
|
|
rep = sympify(rep)
|
|
|
|
if rep.is_Poly:
|
|
return cls._from_poly(rep, opt)
|
|
else:
|
|
return cls._from_expr(rep, opt)
|
|
|
|
# Poly does not pass its args to Basic.__new__ to be stored in _args so we
|
|
# have to emulate them here with an args property that derives from rep
|
|
# and gens which are instance attributes. This also means we need to
|
|
# define _hashable_content. The _hashable_content is rep and gens but args
|
|
# uses expr instead of rep (expr is the Basic version of rep). Passing
|
|
# expr in args means that Basic methods like subs should work. Using rep
|
|
# otherwise means that Poly can remain more efficient than Basic by
|
|
# avoiding creating a Basic instance just to be hashable.
|
|
|
|
@classmethod
|
|
def new(cls, rep, *gens):
|
|
"""Construct :class:`Poly` instance from raw representation. """
|
|
if not isinstance(rep, DMP):
|
|
raise PolynomialError(
|
|
"invalid polynomial representation: %s" % rep)
|
|
elif rep.lev != len(gens) - 1:
|
|
raise PolynomialError("invalid arguments: %s, %s" % (rep, gens))
|
|
|
|
obj = Basic.__new__(cls)
|
|
obj.rep = rep
|
|
obj.gens = gens
|
|
|
|
return obj
|
|
|
|
@property
|
|
def expr(self):
|
|
return basic_from_dict(self.rep.to_sympy_dict(), *self.gens)
|
|
|
|
@property
|
|
def args(self):
|
|
return (self.expr,) + self.gens
|
|
|
|
def _hashable_content(self):
|
|
return (self.rep,) + self.gens
|
|
|
|
@classmethod
|
|
def from_dict(cls, rep, *gens, **args):
|
|
"""Construct a polynomial from a ``dict``. """
|
|
opt = options.build_options(gens, args)
|
|
return cls._from_dict(rep, opt)
|
|
|
|
@classmethod
|
|
def from_list(cls, rep, *gens, **args):
|
|
"""Construct a polynomial from a ``list``. """
|
|
opt = options.build_options(gens, args)
|
|
return cls._from_list(rep, opt)
|
|
|
|
@classmethod
|
|
def from_poly(cls, rep, *gens, **args):
|
|
"""Construct a polynomial from a polynomial. """
|
|
opt = options.build_options(gens, args)
|
|
return cls._from_poly(rep, opt)
|
|
|
|
@classmethod
|
|
def from_expr(cls, rep, *gens, **args):
|
|
"""Construct a polynomial from an expression. """
|
|
opt = options.build_options(gens, args)
|
|
return cls._from_expr(rep, opt)
|
|
|
|
@classmethod
|
|
def _from_dict(cls, rep, opt):
|
|
"""Construct a polynomial from a ``dict``. """
|
|
gens = opt.gens
|
|
|
|
if not gens:
|
|
raise GeneratorsNeeded(
|
|
"Cannot initialize from 'dict' without generators")
|
|
|
|
level = len(gens) - 1
|
|
domain = opt.domain
|
|
|
|
if domain is None:
|
|
domain, rep = construct_domain(rep, opt=opt)
|
|
else:
|
|
for monom, coeff in rep.items():
|
|
rep[monom] = domain.convert(coeff)
|
|
|
|
return cls.new(DMP.from_dict(rep, level, domain), *gens)
|
|
|
|
@classmethod
|
|
def _from_list(cls, rep, opt):
|
|
"""Construct a polynomial from a ``list``. """
|
|
gens = opt.gens
|
|
|
|
if not gens:
|
|
raise GeneratorsNeeded(
|
|
"Cannot initialize from 'list' without generators")
|
|
elif len(gens) != 1:
|
|
raise MultivariatePolynomialError(
|
|
"'list' representation not supported")
|
|
|
|
level = len(gens) - 1
|
|
domain = opt.domain
|
|
|
|
if domain is None:
|
|
domain, rep = construct_domain(rep, opt=opt)
|
|
else:
|
|
rep = list(map(domain.convert, rep))
|
|
|
|
return cls.new(DMP.from_list(rep, level, domain), *gens)
|
|
|
|
@classmethod
|
|
def _from_poly(cls, rep, opt):
|
|
"""Construct a polynomial from a polynomial. """
|
|
if cls != rep.__class__:
|
|
rep = cls.new(rep.rep, *rep.gens)
|
|
|
|
gens = opt.gens
|
|
field = opt.field
|
|
domain = opt.domain
|
|
|
|
if gens and rep.gens != gens:
|
|
if set(rep.gens) != set(gens):
|
|
return cls._from_expr(rep.as_expr(), opt)
|
|
else:
|
|
rep = rep.reorder(*gens)
|
|
|
|
if 'domain' in opt and domain:
|
|
rep = rep.set_domain(domain)
|
|
elif field is True:
|
|
rep = rep.to_field()
|
|
|
|
return rep
|
|
|
|
@classmethod
|
|
def _from_expr(cls, rep, opt):
|
|
"""Construct a polynomial from an expression. """
|
|
rep, opt = _dict_from_expr(rep, opt)
|
|
return cls._from_dict(rep, opt)
|
|
|
|
@classmethod
|
|
def _from_domain_element(cls, rep, opt):
|
|
gens = opt.gens
|
|
domain = opt.domain
|
|
|
|
level = len(gens) - 1
|
|
rep = [domain.convert(rep)]
|
|
|
|
return cls.new(DMP.from_list(rep, level, domain), *gens)
|
|
|
|
def __hash__(self):
|
|
return super().__hash__()
|
|
|
|
@property
|
|
def free_symbols(self):
|
|
"""
|
|
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}
|
|
|
|
"""
|
|
symbols = set()
|
|
gens = self.gens
|
|
for i in range(len(gens)):
|
|
for monom in self.monoms():
|
|
if monom[i]:
|
|
symbols |= gens[i].free_symbols
|
|
break
|
|
|
|
return symbols | self.free_symbols_in_domain
|
|
|
|
@property
|
|
def free_symbols_in_domain(self):
|
|
"""
|
|
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}
|
|
|
|
"""
|
|
domain, symbols = self.rep.dom, set()
|
|
|
|
if domain.is_Composite:
|
|
for gen in domain.symbols:
|
|
symbols |= gen.free_symbols
|
|
elif domain.is_EX:
|
|
for coeff in self.coeffs():
|
|
symbols |= coeff.free_symbols
|
|
|
|
return symbols
|
|
|
|
@property
|
|
def gen(self):
|
|
"""
|
|
Return the principal generator.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import Poly
|
|
>>> from sympy.abc import x
|
|
|
|
>>> Poly(x**2 + 1, x).gen
|
|
x
|
|
|
|
"""
|
|
return self.gens[0]
|
|
|
|
@property
|
|
def domain(self):
|
|
"""Get 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
|
|
"""
|
|
return self.get_domain()
|
|
|
|
@property
|
|
def zero(self):
|
|
"""Return zero polynomial with ``self``'s properties. """
|
|
return self.new(self.rep.zero(self.rep.lev, self.rep.dom), *self.gens)
|
|
|
|
@property
|
|
def one(self):
|
|
"""Return one polynomial with ``self``'s properties. """
|
|
return self.new(self.rep.one(self.rep.lev, self.rep.dom), *self.gens)
|
|
|
|
@property
|
|
def unit(self):
|
|
"""Return unit polynomial with ``self``'s properties. """
|
|
return self.new(self.rep.unit(self.rep.lev, self.rep.dom), *self.gens)
|
|
|
|
def unify(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
return per(F), per(G)
|
|
|
|
def _unify(f, g):
|
|
g = sympify(g)
|
|
|
|
if not g.is_Poly:
|
|
try:
|
|
return f.rep.dom, f.per, f.rep, f.rep.per(f.rep.dom.from_sympy(g))
|
|
except CoercionFailed:
|
|
raise UnificationFailed("Cannot unify %s with %s" % (f, g))
|
|
|
|
if isinstance(f.rep, DMP) and isinstance(g.rep, DMP):
|
|
gens = _unify_gens(f.gens, g.gens)
|
|
|
|
dom, lev = f.rep.dom.unify(g.rep.dom, gens), len(gens) - 1
|
|
|
|
if f.gens != gens:
|
|
f_monoms, f_coeffs = _dict_reorder(
|
|
f.rep.to_dict(), f.gens, gens)
|
|
|
|
if f.rep.dom != dom:
|
|
f_coeffs = [dom.convert(c, f.rep.dom) for c in f_coeffs]
|
|
|
|
F = DMP(dict(list(zip(f_monoms, f_coeffs))), dom, lev)
|
|
else:
|
|
F = f.rep.convert(dom)
|
|
|
|
if g.gens != gens:
|
|
g_monoms, g_coeffs = _dict_reorder(
|
|
g.rep.to_dict(), g.gens, gens)
|
|
|
|
if g.rep.dom != dom:
|
|
g_coeffs = [dom.convert(c, g.rep.dom) for c in g_coeffs]
|
|
|
|
G = DMP(dict(list(zip(g_monoms, g_coeffs))), dom, lev)
|
|
else:
|
|
G = g.rep.convert(dom)
|
|
else:
|
|
raise UnificationFailed("Cannot unify %s with %s" % (f, g))
|
|
|
|
cls = f.__class__
|
|
|
|
def per(rep, dom=dom, gens=gens, remove=None):
|
|
if remove is not None:
|
|
gens = gens[:remove] + gens[remove + 1:]
|
|
|
|
if not gens:
|
|
return dom.to_sympy(rep)
|
|
|
|
return cls.new(rep, *gens)
|
|
|
|
return dom, per, F, G
|
|
|
|
def per(f, rep, gens=None, remove=None):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if gens is None:
|
|
gens = f.gens
|
|
|
|
if remove is not None:
|
|
gens = gens[:remove] + gens[remove + 1:]
|
|
|
|
if not gens:
|
|
return f.rep.dom.to_sympy(rep)
|
|
|
|
return f.__class__.new(rep, *gens)
|
|
|
|
def set_domain(f, domain):
|
|
"""Set the ground domain of ``f``. """
|
|
opt = options.build_options(f.gens, {'domain': domain})
|
|
return f.per(f.rep.convert(opt.domain))
|
|
|
|
def get_domain(f):
|
|
"""Get the ground domain of ``f``. """
|
|
return f.rep.dom
|
|
|
|
def set_modulus(f, modulus):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
modulus = options.Modulus.preprocess(modulus)
|
|
return f.set_domain(FF(modulus))
|
|
|
|
def get_modulus(f):
|
|
"""
|
|
Get the modulus of ``f``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import Poly
|
|
>>> from sympy.abc import x
|
|
|
|
>>> Poly(x**2 + 1, modulus=2).get_modulus()
|
|
2
|
|
|
|
"""
|
|
domain = f.get_domain()
|
|
|
|
if domain.is_FiniteField:
|
|
return Integer(domain.characteristic())
|
|
else:
|
|
raise PolynomialError("not a polynomial over a Galois field")
|
|
|
|
def _eval_subs(f, old, new):
|
|
"""Internal implementation of :func:`subs`. """
|
|
if old in f.gens:
|
|
if new.is_number:
|
|
return f.eval(old, new)
|
|
else:
|
|
try:
|
|
return f.replace(old, new)
|
|
except PolynomialError:
|
|
pass
|
|
|
|
return f.as_expr().subs(old, new)
|
|
|
|
def exclude(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
J, new = f.rep.exclude()
|
|
gens = [gen for j, gen in enumerate(f.gens) if j not in J]
|
|
|
|
return f.per(new, gens=gens)
|
|
|
|
def replace(f, x, y=None, **_ignore):
|
|
# XXX this does not match Basic's signature
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if y is None:
|
|
if f.is_univariate:
|
|
x, y = f.gen, x
|
|
else:
|
|
raise PolynomialError(
|
|
"syntax supported only in univariate case")
|
|
|
|
if x == y or x not in f.gens:
|
|
return f
|
|
|
|
if x in f.gens and y not in f.gens:
|
|
dom = f.get_domain()
|
|
|
|
if not dom.is_Composite or y not in dom.symbols:
|
|
gens = list(f.gens)
|
|
gens[gens.index(x)] = y
|
|
return f.per(f.rep, gens=gens)
|
|
|
|
raise PolynomialError("Cannot replace %s with %s in %s" % (x, y, f))
|
|
|
|
def match(f, *args, **kwargs):
|
|
"""Match expression from Poly. See Basic.match()"""
|
|
return f.as_expr().match(*args, **kwargs)
|
|
|
|
def reorder(f, *gens, **args):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
opt = options.Options((), args)
|
|
|
|
if not gens:
|
|
gens = _sort_gens(f.gens, opt=opt)
|
|
elif set(f.gens) != set(gens):
|
|
raise PolynomialError(
|
|
"generators list can differ only up to order of elements")
|
|
|
|
rep = dict(list(zip(*_dict_reorder(f.rep.to_dict(), f.gens, gens))))
|
|
|
|
return f.per(DMP(rep, f.rep.dom, len(gens) - 1), gens=gens)
|
|
|
|
def ltrim(f, gen):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
rep = f.as_dict(native=True)
|
|
j = f._gen_to_level(gen)
|
|
|
|
terms = {}
|
|
|
|
for monom, coeff in rep.items():
|
|
|
|
if any(monom[:j]):
|
|
# some generator is used in the portion to be trimmed
|
|
raise PolynomialError("Cannot left trim %s" % f)
|
|
|
|
terms[monom[j:]] = coeff
|
|
|
|
gens = f.gens[j:]
|
|
|
|
return f.new(DMP.from_dict(terms, len(gens) - 1, f.rep.dom), *gens)
|
|
|
|
def has_only_gens(f, *gens):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
indices = set()
|
|
|
|
for gen in gens:
|
|
try:
|
|
index = f.gens.index(gen)
|
|
except ValueError:
|
|
raise GeneratorsError(
|
|
"%s doesn't have %s as generator" % (f, gen))
|
|
else:
|
|
indices.add(index)
|
|
|
|
for monom in f.monoms():
|
|
for i, elt in enumerate(monom):
|
|
if i not in indices and elt:
|
|
return False
|
|
|
|
return True
|
|
|
|
def to_ring(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'to_ring'):
|
|
result = f.rep.to_ring()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'to_ring')
|
|
|
|
return f.per(result)
|
|
|
|
def to_field(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'to_field'):
|
|
result = f.rep.to_field()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'to_field')
|
|
|
|
return f.per(result)
|
|
|
|
def to_exact(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'to_exact'):
|
|
result = f.rep.to_exact()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'to_exact')
|
|
|
|
return f.per(result)
|
|
|
|
def retract(f, field=None):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
dom, rep = construct_domain(f.as_dict(zero=True),
|
|
field=field, composite=f.domain.is_Composite or None)
|
|
return f.from_dict(rep, f.gens, domain=dom)
|
|
|
|
def slice(f, x, m, n=None):
|
|
"""Take a continuous subsequence of terms of ``f``. """
|
|
if n is None:
|
|
j, m, n = 0, x, m
|
|
else:
|
|
j = f._gen_to_level(x)
|
|
|
|
m, n = int(m), int(n)
|
|
|
|
if hasattr(f.rep, 'slice'):
|
|
result = f.rep.slice(m, n, j)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'slice')
|
|
|
|
return f.per(result)
|
|
|
|
def coeffs(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return [f.rep.dom.to_sympy(c) for c in f.rep.coeffs(order=order)]
|
|
|
|
def monoms(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.monoms(order=order)
|
|
|
|
def terms(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return [(m, f.rep.dom.to_sympy(c)) for m, c in f.rep.terms(order=order)]
|
|
|
|
def all_coeffs(f):
|
|
"""
|
|
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]
|
|
|
|
"""
|
|
return [f.rep.dom.to_sympy(c) for c in f.rep.all_coeffs()]
|
|
|
|
def all_monoms(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.all_monoms()
|
|
|
|
def all_terms(f):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
return [(m, f.rep.dom.to_sympy(c)) for m, c in f.rep.all_terms()]
|
|
|
|
def termwise(f, func, *gens, **args):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
terms = {}
|
|
|
|
for monom, coeff in f.terms():
|
|
result = func(monom, coeff)
|
|
|
|
if isinstance(result, tuple):
|
|
monom, coeff = result
|
|
else:
|
|
coeff = result
|
|
|
|
if coeff:
|
|
if monom not in terms:
|
|
terms[monom] = coeff
|
|
else:
|
|
raise PolynomialError(
|
|
"%s monomial was generated twice" % monom)
|
|
|
|
return f.from_dict(terms, *(gens or f.gens), **args)
|
|
|
|
def length(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return len(f.as_dict())
|
|
|
|
def as_dict(f, native=False, zero=False):
|
|
"""
|
|
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}
|
|
|
|
"""
|
|
if native:
|
|
return f.rep.to_dict(zero=zero)
|
|
else:
|
|
return f.rep.to_sympy_dict(zero=zero)
|
|
|
|
def as_list(f, native=False):
|
|
"""Switch to a ``list`` representation. """
|
|
if native:
|
|
return f.rep.to_list()
|
|
else:
|
|
return f.rep.to_sympy_list()
|
|
|
|
def as_expr(f, *gens):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if not gens:
|
|
return f.expr
|
|
|
|
if len(gens) == 1 and isinstance(gens[0], dict):
|
|
mapping = gens[0]
|
|
gens = list(f.gens)
|
|
|
|
for gen, value in mapping.items():
|
|
try:
|
|
index = gens.index(gen)
|
|
except ValueError:
|
|
raise GeneratorsError(
|
|
"%s doesn't have %s as generator" % (f, gen))
|
|
else:
|
|
gens[index] = value
|
|
|
|
return basic_from_dict(f.rep.to_sympy_dict(), *gens)
|
|
|
|
def as_poly(self, *gens, **args):
|
|
"""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
|
|
|
|
"""
|
|
try:
|
|
poly = Poly(self, *gens, **args)
|
|
|
|
if not poly.is_Poly:
|
|
return None
|
|
else:
|
|
return poly
|
|
except PolynomialError:
|
|
return None
|
|
|
|
def lift(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'lift'):
|
|
result = f.rep.lift()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'lift')
|
|
|
|
return f.per(result)
|
|
|
|
def deflate(f):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
if hasattr(f.rep, 'deflate'):
|
|
J, result = f.rep.deflate()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'deflate')
|
|
|
|
return J, f.per(result)
|
|
|
|
def inject(f, front=False):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
dom = f.rep.dom
|
|
|
|
if dom.is_Numerical:
|
|
return f
|
|
elif not dom.is_Poly:
|
|
raise DomainError("Cannot inject generators over %s" % dom)
|
|
|
|
if hasattr(f.rep, 'inject'):
|
|
result = f.rep.inject(front=front)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'inject')
|
|
|
|
if front:
|
|
gens = dom.symbols + f.gens
|
|
else:
|
|
gens = f.gens + dom.symbols
|
|
|
|
return f.new(result, *gens)
|
|
|
|
def eject(f, *gens):
|
|
"""
|
|
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]')
|
|
|
|
"""
|
|
dom = f.rep.dom
|
|
|
|
if not dom.is_Numerical:
|
|
raise DomainError("Cannot eject generators over %s" % dom)
|
|
|
|
k = len(gens)
|
|
|
|
if f.gens[:k] == gens:
|
|
_gens, front = f.gens[k:], True
|
|
elif f.gens[-k:] == gens:
|
|
_gens, front = f.gens[:-k], False
|
|
else:
|
|
raise NotImplementedError(
|
|
"can only eject front or back generators")
|
|
|
|
dom = dom.inject(*gens)
|
|
|
|
if hasattr(f.rep, 'eject'):
|
|
result = f.rep.eject(dom, front=front)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'eject')
|
|
|
|
return f.new(result, *_gens)
|
|
|
|
def terms_gcd(f):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
if hasattr(f.rep, 'terms_gcd'):
|
|
J, result = f.rep.terms_gcd()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'terms_gcd')
|
|
|
|
return J, f.per(result)
|
|
|
|
def add_ground(f, coeff):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'add_ground'):
|
|
result = f.rep.add_ground(coeff)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'add_ground')
|
|
|
|
return f.per(result)
|
|
|
|
def sub_ground(f, coeff):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'sub_ground'):
|
|
result = f.rep.sub_ground(coeff)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sub_ground')
|
|
|
|
return f.per(result)
|
|
|
|
def mul_ground(f, coeff):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'mul_ground'):
|
|
result = f.rep.mul_ground(coeff)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'mul_ground')
|
|
|
|
return f.per(result)
|
|
|
|
def quo_ground(f, coeff):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'quo_ground'):
|
|
result = f.rep.quo_ground(coeff)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'quo_ground')
|
|
|
|
return f.per(result)
|
|
|
|
def exquo_ground(f, coeff):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'exquo_ground'):
|
|
result = f.rep.exquo_ground(coeff)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'exquo_ground')
|
|
|
|
return f.per(result)
|
|
|
|
def abs(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'abs'):
|
|
result = f.rep.abs()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'abs')
|
|
|
|
return f.per(result)
|
|
|
|
def neg(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'neg'):
|
|
result = f.rep.neg()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'neg')
|
|
|
|
return f.per(result)
|
|
|
|
def add(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
g = sympify(g)
|
|
|
|
if not g.is_Poly:
|
|
return f.add_ground(g)
|
|
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'add'):
|
|
result = F.add(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'add')
|
|
|
|
return per(result)
|
|
|
|
def sub(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
g = sympify(g)
|
|
|
|
if not g.is_Poly:
|
|
return f.sub_ground(g)
|
|
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'sub'):
|
|
result = F.sub(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sub')
|
|
|
|
return per(result)
|
|
|
|
def mul(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
g = sympify(g)
|
|
|
|
if not g.is_Poly:
|
|
return f.mul_ground(g)
|
|
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'mul'):
|
|
result = F.mul(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'mul')
|
|
|
|
return per(result)
|
|
|
|
def sqr(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'sqr'):
|
|
result = f.rep.sqr()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sqr')
|
|
|
|
return f.per(result)
|
|
|
|
def pow(f, n):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
n = int(n)
|
|
|
|
if hasattr(f.rep, 'pow'):
|
|
result = f.rep.pow(n)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'pow')
|
|
|
|
return f.per(result)
|
|
|
|
def pdiv(f, g):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'pdiv'):
|
|
q, r = F.pdiv(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'pdiv')
|
|
|
|
return per(q), per(r)
|
|
|
|
def prem(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'prem'):
|
|
result = F.prem(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'prem')
|
|
|
|
return per(result)
|
|
|
|
def pquo(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'pquo'):
|
|
result = F.pquo(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'pquo')
|
|
|
|
return per(result)
|
|
|
|
def pexquo(f, g):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'pexquo'):
|
|
try:
|
|
result = F.pexquo(G)
|
|
except ExactQuotientFailed as exc:
|
|
raise exc.new(f.as_expr(), g.as_expr())
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'pexquo')
|
|
|
|
return per(result)
|
|
|
|
def div(f, g, auto=True):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
retract = False
|
|
|
|
if auto and dom.is_Ring and not dom.is_Field:
|
|
F, G = F.to_field(), G.to_field()
|
|
retract = True
|
|
|
|
if hasattr(f.rep, 'div'):
|
|
q, r = F.div(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'div')
|
|
|
|
if retract:
|
|
try:
|
|
Q, R = q.to_ring(), r.to_ring()
|
|
except CoercionFailed:
|
|
pass
|
|
else:
|
|
q, r = Q, R
|
|
|
|
return per(q), per(r)
|
|
|
|
def rem(f, g, auto=True):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
retract = False
|
|
|
|
if auto and dom.is_Ring and not dom.is_Field:
|
|
F, G = F.to_field(), G.to_field()
|
|
retract = True
|
|
|
|
if hasattr(f.rep, 'rem'):
|
|
r = F.rem(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'rem')
|
|
|
|
if retract:
|
|
try:
|
|
r = r.to_ring()
|
|
except CoercionFailed:
|
|
pass
|
|
|
|
return per(r)
|
|
|
|
def quo(f, g, auto=True):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
retract = False
|
|
|
|
if auto and dom.is_Ring and not dom.is_Field:
|
|
F, G = F.to_field(), G.to_field()
|
|
retract = True
|
|
|
|
if hasattr(f.rep, 'quo'):
|
|
q = F.quo(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'quo')
|
|
|
|
if retract:
|
|
try:
|
|
q = q.to_ring()
|
|
except CoercionFailed:
|
|
pass
|
|
|
|
return per(q)
|
|
|
|
def exquo(f, g, auto=True):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
retract = False
|
|
|
|
if auto and dom.is_Ring and not dom.is_Field:
|
|
F, G = F.to_field(), G.to_field()
|
|
retract = True
|
|
|
|
if hasattr(f.rep, 'exquo'):
|
|
try:
|
|
q = F.exquo(G)
|
|
except ExactQuotientFailed as exc:
|
|
raise exc.new(f.as_expr(), g.as_expr())
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'exquo')
|
|
|
|
if retract:
|
|
try:
|
|
q = q.to_ring()
|
|
except CoercionFailed:
|
|
pass
|
|
|
|
return per(q)
|
|
|
|
def _gen_to_level(f, gen):
|
|
"""Returns level associated with the given generator. """
|
|
if isinstance(gen, int):
|
|
length = len(f.gens)
|
|
|
|
if -length <= gen < length:
|
|
if gen < 0:
|
|
return length + gen
|
|
else:
|
|
return gen
|
|
else:
|
|
raise PolynomialError("-%s <= gen < %s expected, got %s" %
|
|
(length, length, gen))
|
|
else:
|
|
try:
|
|
return f.gens.index(sympify(gen))
|
|
except ValueError:
|
|
raise PolynomialError(
|
|
"a valid generator expected, got %s" % gen)
|
|
|
|
def degree(f, gen=0):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
j = f._gen_to_level(gen)
|
|
|
|
if hasattr(f.rep, 'degree'):
|
|
return f.rep.degree(j)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'degree')
|
|
|
|
def degree_list(f):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
if hasattr(f.rep, 'degree_list'):
|
|
return f.rep.degree_list()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'degree_list')
|
|
|
|
def total_degree(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'total_degree'):
|
|
return f.rep.total_degree()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'total_degree')
|
|
|
|
def homogenize(f, s):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if not isinstance(s, Symbol):
|
|
raise TypeError("``Symbol`` expected, got %s" % type(s))
|
|
if s in f.gens:
|
|
i = f.gens.index(s)
|
|
gens = f.gens
|
|
else:
|
|
i = len(f.gens)
|
|
gens = f.gens + (s,)
|
|
if hasattr(f.rep, 'homogenize'):
|
|
return f.per(f.rep.homogenize(i), gens=gens)
|
|
raise OperationNotSupported(f, 'homogeneous_order')
|
|
|
|
def homogeneous_order(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'homogeneous_order'):
|
|
return f.rep.homogeneous_order()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'homogeneous_order')
|
|
|
|
def LC(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if order is not None:
|
|
return f.coeffs(order)[0]
|
|
|
|
if hasattr(f.rep, 'LC'):
|
|
result = f.rep.LC()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'LC')
|
|
|
|
return f.rep.dom.to_sympy(result)
|
|
|
|
def TC(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'TC'):
|
|
result = f.rep.TC()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'TC')
|
|
|
|
return f.rep.dom.to_sympy(result)
|
|
|
|
def EC(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'coeffs'):
|
|
return f.coeffs(order)[-1]
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'EC')
|
|
|
|
def coeff_monomial(f, monom):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.nth(*Monomial(monom, f.gens).exponents)
|
|
|
|
def nth(f, *N):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'nth'):
|
|
if len(N) != len(f.gens):
|
|
raise ValueError('exponent of each generator must be specified')
|
|
result = f.rep.nth(*list(map(int, N)))
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'nth')
|
|
|
|
return f.rep.dom.to_sympy(result)
|
|
|
|
def coeff(f, x, n=1, right=False):
|
|
# the semantics of coeff_monomial and Expr.coeff are different;
|
|
# if someone is working with a Poly, they should be aware of the
|
|
# differences and chose the method best suited for the query.
|
|
# Alternatively, a pure-polys method could be written here but
|
|
# at this time the ``right`` keyword would be ignored because Poly
|
|
# doesn't work with non-commutatives.
|
|
raise NotImplementedError(
|
|
'Either convert to Expr with `as_expr` method '
|
|
'to use Expr\'s coeff method or else use the '
|
|
'`coeff_monomial` method of Polys.')
|
|
|
|
def LM(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return Monomial(f.monoms(order)[0], f.gens)
|
|
|
|
def EM(f, order=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return Monomial(f.monoms(order)[-1], f.gens)
|
|
|
|
def LT(f, order=None):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
monom, coeff = f.terms(order)[0]
|
|
return Monomial(monom, f.gens), coeff
|
|
|
|
def ET(f, order=None):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
monom, coeff = f.terms(order)[-1]
|
|
return Monomial(monom, f.gens), coeff
|
|
|
|
def max_norm(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'max_norm'):
|
|
result = f.rep.max_norm()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'max_norm')
|
|
|
|
return f.rep.dom.to_sympy(result)
|
|
|
|
def l1_norm(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'l1_norm'):
|
|
result = f.rep.l1_norm()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'l1_norm')
|
|
|
|
return f.rep.dom.to_sympy(result)
|
|
|
|
def clear_denoms(self, convert=False):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
f = self
|
|
|
|
if not f.rep.dom.is_Field:
|
|
return S.One, f
|
|
|
|
dom = f.get_domain()
|
|
if dom.has_assoc_Ring:
|
|
dom = f.rep.dom.get_ring()
|
|
|
|
if hasattr(f.rep, 'clear_denoms'):
|
|
coeff, result = f.rep.clear_denoms()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'clear_denoms')
|
|
|
|
coeff, f = dom.to_sympy(coeff), f.per(result)
|
|
|
|
if not convert or not dom.has_assoc_Ring:
|
|
return coeff, f
|
|
else:
|
|
return coeff, f.to_ring()
|
|
|
|
def rat_clear_denoms(self, g):
|
|
"""
|
|
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]')
|
|
|
|
"""
|
|
f = self
|
|
|
|
dom, per, f, g = f._unify(g)
|
|
|
|
f = per(f)
|
|
g = per(g)
|
|
|
|
if not (dom.is_Field and dom.has_assoc_Ring):
|
|
return f, g
|
|
|
|
a, f = f.clear_denoms(convert=True)
|
|
b, g = g.clear_denoms(convert=True)
|
|
|
|
f = f.mul_ground(b)
|
|
g = g.mul_ground(a)
|
|
|
|
return f, g
|
|
|
|
def integrate(self, *specs, **args):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
f = self
|
|
|
|
if args.get('auto', True) and f.rep.dom.is_Ring:
|
|
f = f.to_field()
|
|
|
|
if hasattr(f.rep, 'integrate'):
|
|
if not specs:
|
|
return f.per(f.rep.integrate(m=1))
|
|
|
|
rep = f.rep
|
|
|
|
for spec in specs:
|
|
if isinstance(spec, tuple):
|
|
gen, m = spec
|
|
else:
|
|
gen, m = spec, 1
|
|
|
|
rep = rep.integrate(int(m), f._gen_to_level(gen))
|
|
|
|
return f.per(rep)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'integrate')
|
|
|
|
def diff(f, *specs, **kwargs):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if not kwargs.get('evaluate', True):
|
|
return Derivative(f, *specs, **kwargs)
|
|
|
|
if hasattr(f.rep, 'diff'):
|
|
if not specs:
|
|
return f.per(f.rep.diff(m=1))
|
|
|
|
rep = f.rep
|
|
|
|
for spec in specs:
|
|
if isinstance(spec, tuple):
|
|
gen, m = spec
|
|
else:
|
|
gen, m = spec, 1
|
|
|
|
rep = rep.diff(int(m), f._gen_to_level(gen))
|
|
|
|
return f.per(rep)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'diff')
|
|
|
|
_eval_derivative = diff
|
|
|
|
def eval(self, x, a=None, auto=True):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
f = self
|
|
|
|
if a is None:
|
|
if isinstance(x, dict):
|
|
mapping = x
|
|
|
|
for gen, value in mapping.items():
|
|
f = f.eval(gen, value)
|
|
|
|
return f
|
|
elif isinstance(x, (tuple, list)):
|
|
values = x
|
|
|
|
if len(values) > len(f.gens):
|
|
raise ValueError("too many values provided")
|
|
|
|
for gen, value in zip(f.gens, values):
|
|
f = f.eval(gen, value)
|
|
|
|
return f
|
|
else:
|
|
j, a = 0, x
|
|
else:
|
|
j = f._gen_to_level(x)
|
|
|
|
if not hasattr(f.rep, 'eval'): # pragma: no cover
|
|
raise OperationNotSupported(f, 'eval')
|
|
|
|
try:
|
|
result = f.rep.eval(a, j)
|
|
except CoercionFailed:
|
|
if not auto:
|
|
raise DomainError("Cannot evaluate at %s in %s" % (a, f.rep.dom))
|
|
else:
|
|
a_domain, [a] = construct_domain([a])
|
|
new_domain = f.get_domain().unify_with_symbols(a_domain, f.gens)
|
|
|
|
f = f.set_domain(new_domain)
|
|
a = new_domain.convert(a, a_domain)
|
|
|
|
result = f.rep.eval(a, j)
|
|
|
|
return f.per(result, remove=j)
|
|
|
|
def __call__(f, *values):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.eval(values)
|
|
|
|
def half_gcdex(f, g, auto=True):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
|
|
if auto and dom.is_Ring:
|
|
F, G = F.to_field(), G.to_field()
|
|
|
|
if hasattr(f.rep, 'half_gcdex'):
|
|
s, h = F.half_gcdex(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'half_gcdex')
|
|
|
|
return per(s), per(h)
|
|
|
|
def gcdex(f, g, auto=True):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
|
|
if auto and dom.is_Ring:
|
|
F, G = F.to_field(), G.to_field()
|
|
|
|
if hasattr(f.rep, 'gcdex'):
|
|
s, t, h = F.gcdex(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'gcdex')
|
|
|
|
return per(s), per(t), per(h)
|
|
|
|
def invert(f, g, auto=True):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
|
|
if auto and dom.is_Ring:
|
|
F, G = F.to_field(), G.to_field()
|
|
|
|
if hasattr(f.rep, 'invert'):
|
|
result = F.invert(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'invert')
|
|
|
|
return per(result)
|
|
|
|
def revert(f, n):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'revert'):
|
|
result = f.rep.revert(int(n))
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'revert')
|
|
|
|
return f.per(result)
|
|
|
|
def subresultants(f, g):
|
|
"""
|
|
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')]
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'subresultants'):
|
|
result = F.subresultants(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'subresultants')
|
|
|
|
return list(map(per, result))
|
|
|
|
def resultant(f, g, includePRS=False):
|
|
"""
|
|
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')])
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'resultant'):
|
|
if includePRS:
|
|
result, R = F.resultant(G, includePRS=includePRS)
|
|
else:
|
|
result = F.resultant(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'resultant')
|
|
|
|
if includePRS:
|
|
return (per(result, remove=0), list(map(per, R)))
|
|
return per(result, remove=0)
|
|
|
|
def discriminant(f):
|
|
"""
|
|
Computes the discriminant of ``f``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import Poly
|
|
>>> from sympy.abc import x
|
|
|
|
>>> Poly(x**2 + 2*x + 3, x).discriminant()
|
|
-8
|
|
|
|
"""
|
|
if hasattr(f.rep, 'discriminant'):
|
|
result = f.rep.discriminant()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'discriminant')
|
|
|
|
return f.per(result, remove=0)
|
|
|
|
def dispersionset(f, g=None):
|
|
r"""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:
|
|
|
|
.. 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<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]
|
|
|
|
See Also
|
|
========
|
|
|
|
dispersion
|
|
|
|
References
|
|
==========
|
|
|
|
1. [ManWright94]_
|
|
2. [Koepf98]_
|
|
3. [Abramov71]_
|
|
4. [Man93]_
|
|
"""
|
|
from sympy.polys.dispersion import dispersionset
|
|
return dispersionset(f, g)
|
|
|
|
def dispersion(f, g=None):
|
|
r"""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:
|
|
|
|
.. 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<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]
|
|
|
|
See Also
|
|
========
|
|
|
|
dispersionset
|
|
|
|
References
|
|
==========
|
|
|
|
1. [ManWright94]_
|
|
2. [Koepf98]_
|
|
3. [Abramov71]_
|
|
4. [Man93]_
|
|
"""
|
|
from sympy.polys.dispersion import dispersion
|
|
return dispersion(f, g)
|
|
|
|
def cofactors(f, g):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'cofactors'):
|
|
h, cff, cfg = F.cofactors(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'cofactors')
|
|
|
|
return per(h), per(cff), per(cfg)
|
|
|
|
def gcd(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'gcd'):
|
|
result = F.gcd(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'gcd')
|
|
|
|
return per(result)
|
|
|
|
def lcm(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'lcm'):
|
|
result = F.lcm(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'lcm')
|
|
|
|
return per(result)
|
|
|
|
def trunc(f, p):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
p = f.rep.dom.convert(p)
|
|
|
|
if hasattr(f.rep, 'trunc'):
|
|
result = f.rep.trunc(p)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'trunc')
|
|
|
|
return f.per(result)
|
|
|
|
def monic(self, auto=True):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
f = self
|
|
|
|
if auto and f.rep.dom.is_Ring:
|
|
f = f.to_field()
|
|
|
|
if hasattr(f.rep, 'monic'):
|
|
result = f.rep.monic()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'monic')
|
|
|
|
return f.per(result)
|
|
|
|
def content(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if hasattr(f.rep, 'content'):
|
|
result = f.rep.content()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'content')
|
|
|
|
return f.rep.dom.to_sympy(result)
|
|
|
|
def primitive(f):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
if hasattr(f.rep, 'primitive'):
|
|
cont, result = f.rep.primitive()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'primitive')
|
|
|
|
return f.rep.dom.to_sympy(cont), f.per(result)
|
|
|
|
def compose(f, g):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
_, per, F, G = f._unify(g)
|
|
|
|
if hasattr(f.rep, 'compose'):
|
|
result = F.compose(G)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'compose')
|
|
|
|
return per(result)
|
|
|
|
def decompose(f):
|
|
"""
|
|
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')]
|
|
|
|
"""
|
|
if hasattr(f.rep, 'decompose'):
|
|
result = f.rep.decompose()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'decompose')
|
|
|
|
return list(map(f.per, result))
|
|
|
|
def shift(f, 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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'shift'):
|
|
result = f.rep.shift(a)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'shift')
|
|
|
|
return f.per(result)
|
|
|
|
def transform(f, p, q):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
P, Q = p.unify(q)
|
|
F, P = f.unify(P)
|
|
F, Q = F.unify(Q)
|
|
|
|
if hasattr(F.rep, 'transform'):
|
|
result = F.rep.transform(P.rep, Q.rep)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(F, 'transform')
|
|
|
|
return F.per(result)
|
|
|
|
def sturm(self, auto=True):
|
|
"""
|
|
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')]
|
|
|
|
"""
|
|
f = self
|
|
|
|
if auto and f.rep.dom.is_Ring:
|
|
f = f.to_field()
|
|
|
|
if hasattr(f.rep, 'sturm'):
|
|
result = f.rep.sturm()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sturm')
|
|
|
|
return list(map(f.per, result))
|
|
|
|
def gff_list(f):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
if hasattr(f.rep, 'gff_list'):
|
|
result = f.rep.gff_list()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'gff_list')
|
|
|
|
return [(f.per(g), k) for g, k in result]
|
|
|
|
def norm(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'norm'):
|
|
r = f.rep.norm()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'norm')
|
|
|
|
return f.per(r)
|
|
|
|
def sqf_norm(f):
|
|
"""
|
|
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<sqrt(3)>')
|
|
>>> r
|
|
Poly(x**4 - 4*x**2 + 16, x, domain='QQ')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'sqf_norm'):
|
|
s, g, r = f.rep.sqf_norm()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sqf_norm')
|
|
|
|
return s, f.per(g), f.per(r)
|
|
|
|
def sqf_part(f):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if hasattr(f.rep, 'sqf_part'):
|
|
result = f.rep.sqf_part()
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sqf_part')
|
|
|
|
return f.per(result)
|
|
|
|
def sqf_list(f, all=False):
|
|
"""
|
|
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)])
|
|
|
|
"""
|
|
if hasattr(f.rep, 'sqf_list'):
|
|
coeff, factors = f.rep.sqf_list(all)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sqf_list')
|
|
|
|
return f.rep.dom.to_sympy(coeff), [(f.per(g), k) for g, k in factors]
|
|
|
|
def sqf_list_include(f, all=False):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
if hasattr(f.rep, 'sqf_list_include'):
|
|
factors = f.rep.sqf_list_include(all)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'sqf_list_include')
|
|
|
|
return [(f.per(g), k) for g, k in factors]
|
|
|
|
def factor_list(f):
|
|
"""
|
|
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)])
|
|
|
|
"""
|
|
if hasattr(f.rep, 'factor_list'):
|
|
try:
|
|
coeff, factors = f.rep.factor_list()
|
|
except DomainError:
|
|
return S.One, [(f, 1)]
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'factor_list')
|
|
|
|
return f.rep.dom.to_sympy(coeff), [(f.per(g), k) for g, k in factors]
|
|
|
|
def factor_list_include(f):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
if hasattr(f.rep, 'factor_list_include'):
|
|
try:
|
|
factors = f.rep.factor_list_include()
|
|
except DomainError:
|
|
return [(f, 1)]
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'factor_list_include')
|
|
|
|
return [(f.per(g), k) for g, k in factors]
|
|
|
|
def intervals(f, all=False, eps=None, inf=None, sup=None, fast=False, sqf=False):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
if eps is not None:
|
|
eps = QQ.convert(eps)
|
|
|
|
if eps <= 0:
|
|
raise ValueError("'eps' must be a positive rational")
|
|
|
|
if inf is not None:
|
|
inf = QQ.convert(inf)
|
|
if sup is not None:
|
|
sup = QQ.convert(sup)
|
|
|
|
if hasattr(f.rep, 'intervals'):
|
|
result = f.rep.intervals(
|
|
all=all, eps=eps, inf=inf, sup=sup, fast=fast, sqf=sqf)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'intervals')
|
|
|
|
if sqf:
|
|
def _real(interval):
|
|
s, t = interval
|
|
return (QQ.to_sympy(s), QQ.to_sympy(t))
|
|
|
|
if not all:
|
|
return list(map(_real, result))
|
|
|
|
def _complex(rectangle):
|
|
(u, v), (s, t) = rectangle
|
|
return (QQ.to_sympy(u) + I*QQ.to_sympy(v),
|
|
QQ.to_sympy(s) + I*QQ.to_sympy(t))
|
|
|
|
real_part, complex_part = result
|
|
|
|
return list(map(_real, real_part)), list(map(_complex, complex_part))
|
|
else:
|
|
def _real(interval):
|
|
(s, t), k = interval
|
|
return ((QQ.to_sympy(s), QQ.to_sympy(t)), k)
|
|
|
|
if not all:
|
|
return list(map(_real, result))
|
|
|
|
def _complex(rectangle):
|
|
((u, v), (s, t)), k = rectangle
|
|
return ((QQ.to_sympy(u) + I*QQ.to_sympy(v),
|
|
QQ.to_sympy(s) + I*QQ.to_sympy(t)), k)
|
|
|
|
real_part, complex_part = result
|
|
|
|
return list(map(_real, real_part)), list(map(_complex, complex_part))
|
|
|
|
def refine_root(f, s, t, eps=None, steps=None, fast=False, check_sqf=False):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
if check_sqf and not f.is_sqf:
|
|
raise PolynomialError("only square-free polynomials supported")
|
|
|
|
s, t = QQ.convert(s), QQ.convert(t)
|
|
|
|
if eps is not None:
|
|
eps = QQ.convert(eps)
|
|
|
|
if eps <= 0:
|
|
raise ValueError("'eps' must be a positive rational")
|
|
|
|
if steps is not None:
|
|
steps = int(steps)
|
|
elif eps is None:
|
|
steps = 1
|
|
|
|
if hasattr(f.rep, 'refine_root'):
|
|
S, T = f.rep.refine_root(s, t, eps=eps, steps=steps, fast=fast)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'refine_root')
|
|
|
|
return QQ.to_sympy(S), QQ.to_sympy(T)
|
|
|
|
def count_roots(f, inf=None, sup=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
inf_real, sup_real = True, True
|
|
|
|
if inf is not None:
|
|
inf = sympify(inf)
|
|
|
|
if inf is S.NegativeInfinity:
|
|
inf = None
|
|
else:
|
|
re, im = inf.as_real_imag()
|
|
|
|
if not im:
|
|
inf = QQ.convert(inf)
|
|
else:
|
|
inf, inf_real = list(map(QQ.convert, (re, im))), False
|
|
|
|
if sup is not None:
|
|
sup = sympify(sup)
|
|
|
|
if sup is S.Infinity:
|
|
sup = None
|
|
else:
|
|
re, im = sup.as_real_imag()
|
|
|
|
if not im:
|
|
sup = QQ.convert(sup)
|
|
else:
|
|
sup, sup_real = list(map(QQ.convert, (re, im))), False
|
|
|
|
if inf_real and sup_real:
|
|
if hasattr(f.rep, 'count_real_roots'):
|
|
count = f.rep.count_real_roots(inf=inf, sup=sup)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'count_real_roots')
|
|
else:
|
|
if inf_real and inf is not None:
|
|
inf = (inf, QQ.zero)
|
|
|
|
if sup_real and sup is not None:
|
|
sup = (sup, QQ.zero)
|
|
|
|
if hasattr(f.rep, 'count_complex_roots'):
|
|
count = f.rep.count_complex_roots(inf=inf, sup=sup)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'count_complex_roots')
|
|
|
|
return Integer(count)
|
|
|
|
def root(f, index, radicals=True):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
return sympy.polys.rootoftools.rootof(f, index, radicals=radicals)
|
|
|
|
def real_roots(f, multiple=True, radicals=True):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
reals = sympy.polys.rootoftools.CRootOf.real_roots(f, radicals=radicals)
|
|
|
|
if multiple:
|
|
return reals
|
|
else:
|
|
return group(reals, multiple=False)
|
|
|
|
def all_roots(f, multiple=True, radicals=True):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
roots = sympy.polys.rootoftools.CRootOf.all_roots(f, radicals=radicals)
|
|
|
|
if multiple:
|
|
return roots
|
|
else:
|
|
return group(roots, multiple=False)
|
|
|
|
def nroots(f, n=15, maxsteps=50, cleanup=True):
|
|
"""
|
|
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]
|
|
|
|
"""
|
|
if f.is_multivariate:
|
|
raise MultivariatePolynomialError(
|
|
"Cannot compute numerical roots of %s" % f)
|
|
|
|
if f.degree() <= 0:
|
|
return []
|
|
|
|
# For integer and rational coefficients, convert them to integers only
|
|
# (for accuracy). Otherwise just try to convert the coefficients to
|
|
# mpmath.mpc and raise an exception if the conversion fails.
|
|
if f.rep.dom is ZZ:
|
|
coeffs = [int(coeff) for coeff in f.all_coeffs()]
|
|
elif f.rep.dom is QQ:
|
|
denoms = [coeff.q for coeff in f.all_coeffs()]
|
|
fac = ilcm(*denoms)
|
|
coeffs = [int(coeff*fac) for coeff in f.all_coeffs()]
|
|
else:
|
|
coeffs = [coeff.evalf(n=n).as_real_imag()
|
|
for coeff in f.all_coeffs()]
|
|
try:
|
|
coeffs = [mpmath.mpc(*coeff) for coeff in coeffs]
|
|
except TypeError:
|
|
raise DomainError("Numerical domain expected, got %s" % \
|
|
f.rep.dom)
|
|
|
|
dps = mpmath.mp.dps
|
|
mpmath.mp.dps = n
|
|
|
|
from sympy.functions.elementary.complexes import sign
|
|
try:
|
|
# We need to add extra precision to guard against losing accuracy.
|
|
# 10 times the degree of the polynomial seems to work well.
|
|
roots = mpmath.polyroots(coeffs, maxsteps=maxsteps,
|
|
cleanup=cleanup, error=False, extraprec=f.degree()*10)
|
|
|
|
# Mpmath puts real roots first, then complex ones (as does all_roots)
|
|
# so we make sure this convention holds here, too.
|
|
roots = list(map(sympify,
|
|
sorted(roots, key=lambda r: (1 if r.imag else 0, r.real, abs(r.imag), sign(r.imag)))))
|
|
except NoConvergence:
|
|
try:
|
|
# If roots did not converge try again with more extra precision.
|
|
roots = mpmath.polyroots(coeffs, maxsteps=maxsteps,
|
|
cleanup=cleanup, error=False, extraprec=f.degree()*15)
|
|
roots = list(map(sympify,
|
|
sorted(roots, key=lambda r: (1 if r.imag else 0, r.real, abs(r.imag), sign(r.imag)))))
|
|
except NoConvergence:
|
|
raise NoConvergence(
|
|
'convergence to root failed; try n < %s or maxsteps > %s' % (
|
|
n, maxsteps))
|
|
finally:
|
|
mpmath.mp.dps = dps
|
|
|
|
return roots
|
|
|
|
def ground_roots(f):
|
|
"""
|
|
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}
|
|
|
|
"""
|
|
if f.is_multivariate:
|
|
raise MultivariatePolynomialError(
|
|
"Cannot compute ground roots of %s" % f)
|
|
|
|
roots = {}
|
|
|
|
for factor, k in f.factor_list()[1]:
|
|
if factor.is_linear:
|
|
a, b = factor.all_coeffs()
|
|
roots[-b/a] = k
|
|
|
|
return roots
|
|
|
|
def nth_power_roots_poly(f, n):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
if f.is_multivariate:
|
|
raise MultivariatePolynomialError(
|
|
"must be a univariate polynomial")
|
|
|
|
N = sympify(n)
|
|
|
|
if N.is_Integer and N >= 1:
|
|
n = int(N)
|
|
else:
|
|
raise ValueError("'n' must an integer and n >= 1, got %s" % n)
|
|
|
|
x = f.gen
|
|
t = Dummy('t')
|
|
|
|
r = f.resultant(f.__class__.from_expr(x**n - t, x, t))
|
|
|
|
return r.replace(t, x)
|
|
|
|
def same_root(f, a, b):
|
|
"""
|
|
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.
|
|
|
|
"""
|
|
if f.is_multivariate:
|
|
raise MultivariatePolynomialError(
|
|
"Must be a univariate polynomial")
|
|
|
|
dom_delta_sq = f.rep.mignotte_sep_bound_squared()
|
|
delta_sq = f.domain.get_field().to_sympy(dom_delta_sq)
|
|
# We have delta_sq = delta**2, where delta is a lower bound on the
|
|
# minimum separation between any two roots of this polynomial.
|
|
# Let eps = delta/3, and define eps_sq = eps**2 = delta**2/9.
|
|
eps_sq = delta_sq / 9
|
|
|
|
r, _, _, _ = evalf(1/eps_sq, 1, {})
|
|
n = fastlog(r)
|
|
# Then 2^n > 1/eps**2.
|
|
m = (n // 2) + (n % 2)
|
|
# Then 2^(-m) < eps.
|
|
ev = lambda x: quad_to_mpmath(_evalf_with_bounded_error(x, m=m))
|
|
|
|
# Then for any complex numbers a, b we will have
|
|
# |a - ev(a)| < eps and |b - ev(b)| < eps.
|
|
# So if |ev(a) - ev(b)|**2 < eps**2, then
|
|
# |ev(a) - ev(b)| < eps, hence |a - b| < 3*eps = delta.
|
|
A, B = ev(a), ev(b)
|
|
return (A.real - B.real)**2 + (A.imag - B.imag)**2 < eps_sq
|
|
|
|
def cancel(f, g, include=False):
|
|
"""
|
|
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'))
|
|
|
|
"""
|
|
dom, per, F, G = f._unify(g)
|
|
|
|
if hasattr(F, 'cancel'):
|
|
result = F.cancel(G, include=include)
|
|
else: # pragma: no cover
|
|
raise OperationNotSupported(f, 'cancel')
|
|
|
|
if not include:
|
|
if dom.has_assoc_Ring:
|
|
dom = dom.get_ring()
|
|
|
|
cp, cq, p, q = result
|
|
|
|
cp = dom.to_sympy(cp)
|
|
cq = dom.to_sympy(cq)
|
|
|
|
return cp/cq, per(p), per(q)
|
|
else:
|
|
return tuple(map(per, result))
|
|
|
|
def make_monic_over_integers_by_scaling_roots(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
if not f.is_univariate or f.domain not in [ZZ, QQ]:
|
|
raise ValueError('Polynomial must be univariate over ZZ or QQ.')
|
|
if f.is_monic and f.domain == ZZ:
|
|
return f, ZZ.one
|
|
else:
|
|
fm = f.monic()
|
|
c, _ = fm.clear_denoms()
|
|
return fm.transform(Poly(fm.gen), c).to_ring(), c
|
|
|
|
def galois_group(f, by_name=False, max_tries=30, randomize=False):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
from sympy.polys.numberfields.galoisgroups import (
|
|
_galois_group_degree_3, _galois_group_degree_4_lookup,
|
|
_galois_group_degree_5_lookup_ext_factor,
|
|
_galois_group_degree_6_lookup,
|
|
)
|
|
if (not f.is_univariate
|
|
or not f.is_irreducible
|
|
or f.domain not in [ZZ, QQ]
|
|
):
|
|
raise ValueError('Polynomial must be irreducible and univariate over ZZ or QQ.')
|
|
gg = {
|
|
3: _galois_group_degree_3,
|
|
4: _galois_group_degree_4_lookup,
|
|
5: _galois_group_degree_5_lookup_ext_factor,
|
|
6: _galois_group_degree_6_lookup,
|
|
}
|
|
max_supported = max(gg.keys())
|
|
n = f.degree()
|
|
if n > max_supported:
|
|
raise ValueError(f"Only polynomials up to degree {max_supported} are supported.")
|
|
elif n < 1:
|
|
raise ValueError("Constant polynomial has no Galois group.")
|
|
elif n == 1:
|
|
from sympy.combinatorics.galois import S1TransitiveSubgroups
|
|
name, alt = S1TransitiveSubgroups.S1, True
|
|
elif n == 2:
|
|
from sympy.combinatorics.galois import S2TransitiveSubgroups
|
|
name, alt = S2TransitiveSubgroups.S2, False
|
|
else:
|
|
g, _ = f.make_monic_over_integers_by_scaling_roots()
|
|
name, alt = gg[n](g, max_tries=max_tries, randomize=randomize)
|
|
G = name if by_name else name.get_perm_group()
|
|
return G, alt
|
|
|
|
@property
|
|
def is_zero(f):
|
|
"""
|
|
Returns ``True`` if ``f`` is a zero polynomial.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import Poly
|
|
>>> from sympy.abc import x
|
|
|
|
>>> Poly(0, x).is_zero
|
|
True
|
|
>>> Poly(1, x).is_zero
|
|
False
|
|
|
|
"""
|
|
return f.rep.is_zero
|
|
|
|
@property
|
|
def is_one(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_one
|
|
|
|
@property
|
|
def is_sqf(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_sqf
|
|
|
|
@property
|
|
def is_monic(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_monic
|
|
|
|
@property
|
|
def is_primitive(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_primitive
|
|
|
|
@property
|
|
def is_ground(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_ground
|
|
|
|
@property
|
|
def is_linear(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_linear
|
|
|
|
@property
|
|
def is_quadratic(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_quadratic
|
|
|
|
@property
|
|
def is_monomial(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_monomial
|
|
|
|
@property
|
|
def is_homogeneous(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_homogeneous
|
|
|
|
@property
|
|
def is_irreducible(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_irreducible
|
|
|
|
@property
|
|
def is_univariate(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return len(f.gens) == 1
|
|
|
|
@property
|
|
def is_multivariate(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return len(f.gens) != 1
|
|
|
|
@property
|
|
def is_cyclotomic(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return f.rep.is_cyclotomic
|
|
|
|
def __abs__(f):
|
|
return f.abs()
|
|
|
|
def __neg__(f):
|
|
return f.neg()
|
|
|
|
@_polifyit
|
|
def __add__(f, g):
|
|
return f.add(g)
|
|
|
|
@_polifyit
|
|
def __radd__(f, g):
|
|
return g.add(f)
|
|
|
|
@_polifyit
|
|
def __sub__(f, g):
|
|
return f.sub(g)
|
|
|
|
@_polifyit
|
|
def __rsub__(f, g):
|
|
return g.sub(f)
|
|
|
|
@_polifyit
|
|
def __mul__(f, g):
|
|
return f.mul(g)
|
|
|
|
@_polifyit
|
|
def __rmul__(f, g):
|
|
return g.mul(f)
|
|
|
|
@_sympifyit('n', NotImplemented)
|
|
def __pow__(f, n):
|
|
if n.is_Integer and n >= 0:
|
|
return f.pow(n)
|
|
else:
|
|
return NotImplemented
|
|
|
|
@_polifyit
|
|
def __divmod__(f, g):
|
|
return f.div(g)
|
|
|
|
@_polifyit
|
|
def __rdivmod__(f, g):
|
|
return g.div(f)
|
|
|
|
@_polifyit
|
|
def __mod__(f, g):
|
|
return f.rem(g)
|
|
|
|
@_polifyit
|
|
def __rmod__(f, g):
|
|
return g.rem(f)
|
|
|
|
@_polifyit
|
|
def __floordiv__(f, g):
|
|
return f.quo(g)
|
|
|
|
@_polifyit
|
|
def __rfloordiv__(f, g):
|
|
return g.quo(f)
|
|
|
|
@_sympifyit('g', NotImplemented)
|
|
def __truediv__(f, g):
|
|
return f.as_expr()/g.as_expr()
|
|
|
|
@_sympifyit('g', NotImplemented)
|
|
def __rtruediv__(f, g):
|
|
return g.as_expr()/f.as_expr()
|
|
|
|
@_sympifyit('other', NotImplemented)
|
|
def __eq__(self, other):
|
|
f, g = self, other
|
|
|
|
if not g.is_Poly:
|
|
try:
|
|
g = f.__class__(g, f.gens, domain=f.get_domain())
|
|
except (PolynomialError, DomainError, CoercionFailed):
|
|
return False
|
|
|
|
if f.gens != g.gens:
|
|
return False
|
|
|
|
if f.rep.dom != g.rep.dom:
|
|
return False
|
|
|
|
return f.rep == g.rep
|
|
|
|
@_sympifyit('g', NotImplemented)
|
|
def __ne__(f, g):
|
|
return not f == g
|
|
|
|
def __bool__(f):
|
|
return not f.is_zero
|
|
|
|
def eq(f, g, strict=False):
|
|
if not strict:
|
|
return f == g
|
|
else:
|
|
return f._strict_eq(sympify(g))
|
|
|
|
def ne(f, g, strict=False):
|
|
return not f.eq(g, strict=strict)
|
|
|
|
def _strict_eq(f, g):
|
|
return isinstance(g, f.__class__) and f.gens == g.gens and f.rep.eq(g.rep, strict=True)
|
|
|
|
|
|
@public
|
|
class PurePoly(Poly):
|
|
"""Class for representing pure polynomials. """
|
|
|
|
def _hashable_content(self):
|
|
"""Allow SymPy to hash Poly instances. """
|
|
return (self.rep,)
|
|
|
|
def __hash__(self):
|
|
return super().__hash__()
|
|
|
|
@property
|
|
def free_symbols(self):
|
|
"""
|
|
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}
|
|
|
|
"""
|
|
return self.free_symbols_in_domain
|
|
|
|
@_sympifyit('other', NotImplemented)
|
|
def __eq__(self, other):
|
|
f, g = self, other
|
|
|
|
if not g.is_Poly:
|
|
try:
|
|
g = f.__class__(g, f.gens, domain=f.get_domain())
|
|
except (PolynomialError, DomainError, CoercionFailed):
|
|
return False
|
|
|
|
if len(f.gens) != len(g.gens):
|
|
return False
|
|
|
|
if f.rep.dom != g.rep.dom:
|
|
try:
|
|
dom = f.rep.dom.unify(g.rep.dom, f.gens)
|
|
except UnificationFailed:
|
|
return False
|
|
|
|
f = f.set_domain(dom)
|
|
g = g.set_domain(dom)
|
|
|
|
return f.rep == g.rep
|
|
|
|
def _strict_eq(f, g):
|
|
return isinstance(g, f.__class__) and f.rep.eq(g.rep, strict=True)
|
|
|
|
def _unify(f, g):
|
|
g = sympify(g)
|
|
|
|
if not g.is_Poly:
|
|
try:
|
|
return f.rep.dom, f.per, f.rep, f.rep.per(f.rep.dom.from_sympy(g))
|
|
except CoercionFailed:
|
|
raise UnificationFailed("Cannot unify %s with %s" % (f, g))
|
|
|
|
if len(f.gens) != len(g.gens):
|
|
raise UnificationFailed("Cannot unify %s with %s" % (f, g))
|
|
|
|
if not (isinstance(f.rep, DMP) and isinstance(g.rep, DMP)):
|
|
raise UnificationFailed("Cannot unify %s with %s" % (f, g))
|
|
|
|
cls = f.__class__
|
|
gens = f.gens
|
|
|
|
dom = f.rep.dom.unify(g.rep.dom, gens)
|
|
|
|
F = f.rep.convert(dom)
|
|
G = g.rep.convert(dom)
|
|
|
|
def per(rep, dom=dom, gens=gens, remove=None):
|
|
if remove is not None:
|
|
gens = gens[:remove] + gens[remove + 1:]
|
|
|
|
if not gens:
|
|
return dom.to_sympy(rep)
|
|
|
|
return cls.new(rep, *gens)
|
|
|
|
return dom, per, F, G
|
|
|
|
|
|
@public
|
|
def poly_from_expr(expr, *gens, **args):
|
|
"""Construct a polynomial from an expression. """
|
|
opt = options.build_options(gens, args)
|
|
return _poly_from_expr(expr, opt)
|
|
|
|
|
|
def _poly_from_expr(expr, opt):
|
|
"""Construct a polynomial from an expression. """
|
|
orig, expr = expr, sympify(expr)
|
|
|
|
if not isinstance(expr, Basic):
|
|
raise PolificationFailed(opt, orig, expr)
|
|
elif expr.is_Poly:
|
|
poly = expr.__class__._from_poly(expr, opt)
|
|
|
|
opt.gens = poly.gens
|
|
opt.domain = poly.domain
|
|
|
|
if opt.polys is None:
|
|
opt.polys = True
|
|
|
|
return poly, opt
|
|
elif opt.expand:
|
|
expr = expr.expand()
|
|
|
|
rep, opt = _dict_from_expr(expr, opt)
|
|
if not opt.gens:
|
|
raise PolificationFailed(opt, orig, expr)
|
|
|
|
monoms, coeffs = list(zip(*list(rep.items())))
|
|
domain = opt.domain
|
|
|
|
if domain is None:
|
|
opt.domain, coeffs = construct_domain(coeffs, opt=opt)
|
|
else:
|
|
coeffs = list(map(domain.from_sympy, coeffs))
|
|
|
|
rep = dict(list(zip(monoms, coeffs)))
|
|
poly = Poly._from_dict(rep, opt)
|
|
|
|
if opt.polys is None:
|
|
opt.polys = False
|
|
|
|
return poly, opt
|
|
|
|
|
|
@public
|
|
def parallel_poly_from_expr(exprs, *gens, **args):
|
|
"""Construct polynomials from expressions. """
|
|
opt = options.build_options(gens, args)
|
|
return _parallel_poly_from_expr(exprs, opt)
|
|
|
|
|
|
def _parallel_poly_from_expr(exprs, opt):
|
|
"""Construct polynomials from expressions. """
|
|
if len(exprs) == 2:
|
|
f, g = exprs
|
|
|
|
if isinstance(f, Poly) and isinstance(g, Poly):
|
|
f = f.__class__._from_poly(f, opt)
|
|
g = g.__class__._from_poly(g, opt)
|
|
|
|
f, g = f.unify(g)
|
|
|
|
opt.gens = f.gens
|
|
opt.domain = f.domain
|
|
|
|
if opt.polys is None:
|
|
opt.polys = True
|
|
|
|
return [f, g], opt
|
|
|
|
origs, exprs = list(exprs), []
|
|
_exprs, _polys = [], []
|
|
|
|
failed = False
|
|
|
|
for i, expr in enumerate(origs):
|
|
expr = sympify(expr)
|
|
|
|
if isinstance(expr, Basic):
|
|
if expr.is_Poly:
|
|
_polys.append(i)
|
|
else:
|
|
_exprs.append(i)
|
|
|
|
if opt.expand:
|
|
expr = expr.expand()
|
|
else:
|
|
failed = True
|
|
|
|
exprs.append(expr)
|
|
|
|
if failed:
|
|
raise PolificationFailed(opt, origs, exprs, True)
|
|
|
|
if _polys:
|
|
# XXX: this is a temporary solution
|
|
for i in _polys:
|
|
exprs[i] = exprs[i].as_expr()
|
|
|
|
reps, opt = _parallel_dict_from_expr(exprs, opt)
|
|
if not opt.gens:
|
|
raise PolificationFailed(opt, origs, exprs, True)
|
|
|
|
from sympy.functions.elementary.piecewise import Piecewise
|
|
for k in opt.gens:
|
|
if isinstance(k, Piecewise):
|
|
raise PolynomialError("Piecewise generators do not make sense")
|
|
|
|
coeffs_list, lengths = [], []
|
|
|
|
all_monoms = []
|
|
all_coeffs = []
|
|
|
|
for rep in reps:
|
|
monoms, coeffs = list(zip(*list(rep.items())))
|
|
|
|
coeffs_list.extend(coeffs)
|
|
all_monoms.append(monoms)
|
|
|
|
lengths.append(len(coeffs))
|
|
|
|
domain = opt.domain
|
|
|
|
if domain is None:
|
|
opt.domain, coeffs_list = construct_domain(coeffs_list, opt=opt)
|
|
else:
|
|
coeffs_list = list(map(domain.from_sympy, coeffs_list))
|
|
|
|
for k in lengths:
|
|
all_coeffs.append(coeffs_list[:k])
|
|
coeffs_list = coeffs_list[k:]
|
|
|
|
polys = []
|
|
|
|
for monoms, coeffs in zip(all_monoms, all_coeffs):
|
|
rep = dict(list(zip(monoms, coeffs)))
|
|
poly = Poly._from_dict(rep, opt)
|
|
polys.append(poly)
|
|
|
|
if opt.polys is None:
|
|
opt.polys = bool(_polys)
|
|
|
|
return polys, opt
|
|
|
|
|
|
def _update_args(args, key, value):
|
|
"""Add a new ``(key, value)`` pair to arguments ``dict``. """
|
|
args = dict(args)
|
|
|
|
if key not in args:
|
|
args[key] = value
|
|
|
|
return args
|
|
|
|
|
|
@public
|
|
def degree(f, gen=0):
|
|
"""
|
|
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
|
|
"""
|
|
|
|
f = sympify(f, strict=True)
|
|
gen_is_Num = sympify(gen, strict=True).is_Number
|
|
if f.is_Poly:
|
|
p = f
|
|
isNum = p.as_expr().is_Number
|
|
else:
|
|
isNum = f.is_Number
|
|
if not isNum:
|
|
if gen_is_Num:
|
|
p, _ = poly_from_expr(f)
|
|
else:
|
|
p, _ = poly_from_expr(f, gen)
|
|
|
|
if isNum:
|
|
return S.Zero if f else S.NegativeInfinity
|
|
|
|
if not gen_is_Num:
|
|
if f.is_Poly and gen not in p.gens:
|
|
# try recast without explicit gens
|
|
p, _ = poly_from_expr(f.as_expr())
|
|
if gen not in p.gens:
|
|
return S.Zero
|
|
elif not f.is_Poly and len(f.free_symbols) > 1:
|
|
raise TypeError(filldedent('''
|
|
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).
|
|
''' % (f, next(ordered(f.free_symbols)), gen)))
|
|
result = p.degree(gen)
|
|
return Integer(result) if isinstance(result, int) else S.NegativeInfinity
|
|
|
|
|
|
@public
|
|
def total_degree(f, *gens):
|
|
"""
|
|
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
|
|
"""
|
|
|
|
p = sympify(f)
|
|
if p.is_Poly:
|
|
p = p.as_expr()
|
|
if p.is_Number:
|
|
rv = 0
|
|
else:
|
|
if f.is_Poly:
|
|
gens = gens or f.gens
|
|
rv = Poly(p, gens).total_degree()
|
|
|
|
return Integer(rv)
|
|
|
|
|
|
@public
|
|
def degree_list(f, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('degree_list', 1, exc)
|
|
|
|
degrees = F.degree_list()
|
|
|
|
return tuple(map(Integer, degrees))
|
|
|
|
|
|
@public
|
|
def LC(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('LC', 1, exc)
|
|
|
|
return F.LC(order=opt.order)
|
|
|
|
|
|
@public
|
|
def LM(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('LM', 1, exc)
|
|
|
|
monom = F.LM(order=opt.order)
|
|
return monom.as_expr()
|
|
|
|
|
|
@public
|
|
def LT(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('LT', 1, exc)
|
|
|
|
monom, coeff = F.LT(order=opt.order)
|
|
return coeff*monom.as_expr()
|
|
|
|
|
|
@public
|
|
def pdiv(f, g, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('pdiv', 2, exc)
|
|
|
|
q, r = F.pdiv(G)
|
|
|
|
if not opt.polys:
|
|
return q.as_expr(), r.as_expr()
|
|
else:
|
|
return q, r
|
|
|
|
|
|
@public
|
|
def prem(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('prem', 2, exc)
|
|
|
|
r = F.prem(G)
|
|
|
|
if not opt.polys:
|
|
return r.as_expr()
|
|
else:
|
|
return r
|
|
|
|
|
|
@public
|
|
def pquo(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('pquo', 2, exc)
|
|
|
|
try:
|
|
q = F.pquo(G)
|
|
except ExactQuotientFailed:
|
|
raise ExactQuotientFailed(f, g)
|
|
|
|
if not opt.polys:
|
|
return q.as_expr()
|
|
else:
|
|
return q
|
|
|
|
|
|
@public
|
|
def pexquo(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('pexquo', 2, exc)
|
|
|
|
q = F.pexquo(G)
|
|
|
|
if not opt.polys:
|
|
return q.as_expr()
|
|
else:
|
|
return q
|
|
|
|
|
|
@public
|
|
def div(f, g, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('div', 2, exc)
|
|
|
|
q, r = F.div(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return q.as_expr(), r.as_expr()
|
|
else:
|
|
return q, r
|
|
|
|
|
|
@public
|
|
def rem(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('rem', 2, exc)
|
|
|
|
r = F.rem(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return r.as_expr()
|
|
else:
|
|
return r
|
|
|
|
|
|
@public
|
|
def quo(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('quo', 2, exc)
|
|
|
|
q = F.quo(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return q.as_expr()
|
|
else:
|
|
return q
|
|
|
|
|
|
@public
|
|
def exquo(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('exquo', 2, exc)
|
|
|
|
q = F.exquo(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return q.as_expr()
|
|
else:
|
|
return q
|
|
|
|
|
|
@public
|
|
def half_gcdex(f, g, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
domain, (a, b) = construct_domain(exc.exprs)
|
|
|
|
try:
|
|
s, h = domain.half_gcdex(a, b)
|
|
except NotImplementedError:
|
|
raise ComputationFailed('half_gcdex', 2, exc)
|
|
else:
|
|
return domain.to_sympy(s), domain.to_sympy(h)
|
|
|
|
s, h = F.half_gcdex(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return s.as_expr(), h.as_expr()
|
|
else:
|
|
return s, h
|
|
|
|
|
|
@public
|
|
def gcdex(f, g, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
domain, (a, b) = construct_domain(exc.exprs)
|
|
|
|
try:
|
|
s, t, h = domain.gcdex(a, b)
|
|
except NotImplementedError:
|
|
raise ComputationFailed('gcdex', 2, exc)
|
|
else:
|
|
return domain.to_sympy(s), domain.to_sympy(t), domain.to_sympy(h)
|
|
|
|
s, t, h = F.gcdex(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return s.as_expr(), t.as_expr(), h.as_expr()
|
|
else:
|
|
return s, t, h
|
|
|
|
|
|
@public
|
|
def invert(f, g, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
domain, (a, b) = construct_domain(exc.exprs)
|
|
|
|
try:
|
|
return domain.to_sympy(domain.invert(a, b))
|
|
except NotImplementedError:
|
|
raise ComputationFailed('invert', 2, exc)
|
|
|
|
h = F.invert(G, auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return h.as_expr()
|
|
else:
|
|
return h
|
|
|
|
|
|
@public
|
|
def subresultants(f, g, *gens, **args):
|
|
"""
|
|
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]
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('subresultants', 2, exc)
|
|
|
|
result = F.subresultants(G)
|
|
|
|
if not opt.polys:
|
|
return [r.as_expr() for r in result]
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def resultant(f, g, *gens, includePRS=False, **args):
|
|
"""
|
|
Compute resultant of ``f`` and ``g``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import resultant
|
|
>>> from sympy.abc import x
|
|
|
|
>>> resultant(x**2 + 1, x**2 - 1)
|
|
4
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('resultant', 2, exc)
|
|
|
|
if includePRS:
|
|
result, R = F.resultant(G, includePRS=includePRS)
|
|
else:
|
|
result = F.resultant(G)
|
|
|
|
if not opt.polys:
|
|
if includePRS:
|
|
return result.as_expr(), [r.as_expr() for r in R]
|
|
return result.as_expr()
|
|
else:
|
|
if includePRS:
|
|
return result, R
|
|
return result
|
|
|
|
|
|
@public
|
|
def discriminant(f, *gens, **args):
|
|
"""
|
|
Compute discriminant of ``f``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import discriminant
|
|
>>> from sympy.abc import x
|
|
|
|
>>> discriminant(x**2 + 2*x + 3)
|
|
-8
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('discriminant', 1, exc)
|
|
|
|
result = F.discriminant()
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def cofactors(f, g, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
domain, (a, b) = construct_domain(exc.exprs)
|
|
|
|
try:
|
|
h, cff, cfg = domain.cofactors(a, b)
|
|
except NotImplementedError:
|
|
raise ComputationFailed('cofactors', 2, exc)
|
|
else:
|
|
return domain.to_sympy(h), domain.to_sympy(cff), domain.to_sympy(cfg)
|
|
|
|
h, cff, cfg = F.cofactors(G)
|
|
|
|
if not opt.polys:
|
|
return h.as_expr(), cff.as_expr(), cfg.as_expr()
|
|
else:
|
|
return h, cff, cfg
|
|
|
|
|
|
@public
|
|
def gcd_list(seq, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
seq = sympify(seq)
|
|
|
|
def try_non_polynomial_gcd(seq):
|
|
if not gens and not args:
|
|
domain, numbers = construct_domain(seq)
|
|
|
|
if not numbers:
|
|
return domain.zero
|
|
elif domain.is_Numerical:
|
|
result, numbers = numbers[0], numbers[1:]
|
|
|
|
for number in numbers:
|
|
result = domain.gcd(result, number)
|
|
|
|
if domain.is_one(result):
|
|
break
|
|
|
|
return domain.to_sympy(result)
|
|
|
|
return None
|
|
|
|
result = try_non_polynomial_gcd(seq)
|
|
|
|
if result is not None:
|
|
return result
|
|
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
polys, opt = parallel_poly_from_expr(seq, *gens, **args)
|
|
|
|
# gcd for domain Q[irrational] (purely algebraic irrational)
|
|
if len(seq) > 1 and all(elt.is_algebraic and elt.is_irrational for elt in seq):
|
|
a = seq[-1]
|
|
lst = [ (a/elt).ratsimp() for elt in seq[:-1] ]
|
|
if all(frc.is_rational for frc in lst):
|
|
lc = 1
|
|
for frc in lst:
|
|
lc = lcm(lc, frc.as_numer_denom()[0])
|
|
# abs ensures that the gcd is always non-negative
|
|
return abs(a/lc)
|
|
|
|
except PolificationFailed as exc:
|
|
result = try_non_polynomial_gcd(exc.exprs)
|
|
|
|
if result is not None:
|
|
return result
|
|
else:
|
|
raise ComputationFailed('gcd_list', len(seq), exc)
|
|
|
|
if not polys:
|
|
if not opt.polys:
|
|
return S.Zero
|
|
else:
|
|
return Poly(0, opt=opt)
|
|
|
|
result, polys = polys[0], polys[1:]
|
|
|
|
for poly in polys:
|
|
result = result.gcd(poly)
|
|
|
|
if result.is_one:
|
|
break
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def gcd(f, g=None, *gens, **args):
|
|
"""
|
|
Compute GCD of ``f`` and ``g``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import gcd
|
|
>>> from sympy.abc import x
|
|
|
|
>>> gcd(x**2 - 1, x**2 - 3*x + 2)
|
|
x - 1
|
|
|
|
"""
|
|
if hasattr(f, '__iter__'):
|
|
if g is not None:
|
|
gens = (g,) + gens
|
|
|
|
return gcd_list(f, *gens, **args)
|
|
elif g is None:
|
|
raise TypeError("gcd() takes 2 arguments or a sequence of arguments")
|
|
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
|
|
# gcd for domain Q[irrational] (purely algebraic irrational)
|
|
a, b = map(sympify, (f, g))
|
|
if a.is_algebraic and a.is_irrational and b.is_algebraic and b.is_irrational:
|
|
frc = (a/b).ratsimp()
|
|
if frc.is_rational:
|
|
# abs ensures that the returned gcd is always non-negative
|
|
return abs(a/frc.as_numer_denom()[0])
|
|
|
|
except PolificationFailed as exc:
|
|
domain, (a, b) = construct_domain(exc.exprs)
|
|
|
|
try:
|
|
return domain.to_sympy(domain.gcd(a, b))
|
|
except NotImplementedError:
|
|
raise ComputationFailed('gcd', 2, exc)
|
|
|
|
result = F.gcd(G)
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def lcm_list(seq, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
seq = sympify(seq)
|
|
|
|
def try_non_polynomial_lcm(seq) -> Optional[Expr]:
|
|
if not gens and not args:
|
|
domain, numbers = construct_domain(seq)
|
|
|
|
if not numbers:
|
|
return domain.to_sympy(domain.one)
|
|
elif domain.is_Numerical:
|
|
result, numbers = numbers[0], numbers[1:]
|
|
|
|
for number in numbers:
|
|
result = domain.lcm(result, number)
|
|
|
|
return domain.to_sympy(result)
|
|
|
|
return None
|
|
|
|
result = try_non_polynomial_lcm(seq)
|
|
|
|
if result is not None:
|
|
return result
|
|
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
polys, opt = parallel_poly_from_expr(seq, *gens, **args)
|
|
|
|
# lcm for domain Q[irrational] (purely algebraic irrational)
|
|
if len(seq) > 1 and all(elt.is_algebraic and elt.is_irrational for elt in seq):
|
|
a = seq[-1]
|
|
lst = [ (a/elt).ratsimp() for elt in seq[:-1] ]
|
|
if all(frc.is_rational for frc in lst):
|
|
lc = 1
|
|
for frc in lst:
|
|
lc = lcm(lc, frc.as_numer_denom()[1])
|
|
return a*lc
|
|
|
|
except PolificationFailed as exc:
|
|
result = try_non_polynomial_lcm(exc.exprs)
|
|
|
|
if result is not None:
|
|
return result
|
|
else:
|
|
raise ComputationFailed('lcm_list', len(seq), exc)
|
|
|
|
if not polys:
|
|
if not opt.polys:
|
|
return S.One
|
|
else:
|
|
return Poly(1, opt=opt)
|
|
|
|
result, polys = polys[0], polys[1:]
|
|
|
|
for poly in polys:
|
|
result = result.lcm(poly)
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def lcm(f, g=None, *gens, **args):
|
|
"""
|
|
Compute LCM of ``f`` and ``g``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import lcm
|
|
>>> from sympy.abc import x
|
|
|
|
>>> lcm(x**2 - 1, x**2 - 3*x + 2)
|
|
x**3 - 2*x**2 - x + 2
|
|
|
|
"""
|
|
if hasattr(f, '__iter__'):
|
|
if g is not None:
|
|
gens = (g,) + gens
|
|
|
|
return lcm_list(f, *gens, **args)
|
|
elif g is None:
|
|
raise TypeError("lcm() takes 2 arguments or a sequence of arguments")
|
|
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
|
|
# lcm for domain Q[irrational] (purely algebraic irrational)
|
|
a, b = map(sympify, (f, g))
|
|
if a.is_algebraic and a.is_irrational and b.is_algebraic and b.is_irrational:
|
|
frc = (a/b).ratsimp()
|
|
if frc.is_rational:
|
|
return a*frc.as_numer_denom()[1]
|
|
|
|
except PolificationFailed as exc:
|
|
domain, (a, b) = construct_domain(exc.exprs)
|
|
|
|
try:
|
|
return domain.to_sympy(domain.lcm(a, b))
|
|
except NotImplementedError:
|
|
raise ComputationFailed('lcm', 2, exc)
|
|
|
|
result = F.lcm(G)
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def terms_gcd(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
|
|
orig = sympify(f)
|
|
|
|
if isinstance(f, Equality):
|
|
return Equality(*(terms_gcd(s, *gens, **args) for s in [f.lhs, f.rhs]))
|
|
elif isinstance(f, Relational):
|
|
raise TypeError("Inequalities cannot be used with terms_gcd. Found: %s" %(f,))
|
|
|
|
if not isinstance(f, Expr) or f.is_Atom:
|
|
return orig
|
|
|
|
if args.get('deep', False):
|
|
new = f.func(*[terms_gcd(a, *gens, **args) for a in f.args])
|
|
args.pop('deep')
|
|
args['expand'] = False
|
|
return terms_gcd(new, *gens, **args)
|
|
|
|
clear = args.pop('clear', True)
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
return exc.expr
|
|
|
|
J, f = F.terms_gcd()
|
|
|
|
if opt.domain.is_Ring:
|
|
if opt.domain.is_Field:
|
|
denom, f = f.clear_denoms(convert=True)
|
|
|
|
coeff, f = f.primitive()
|
|
|
|
if opt.domain.is_Field:
|
|
coeff /= denom
|
|
else:
|
|
coeff = S.One
|
|
|
|
term = Mul(*[x**j for x, j in zip(f.gens, J)])
|
|
if equal_valued(coeff, 1):
|
|
coeff = S.One
|
|
if term == 1:
|
|
return orig
|
|
|
|
if clear:
|
|
return _keep_coeff(coeff, term*f.as_expr())
|
|
# base the clearing on the form of the original expression, not
|
|
# the (perhaps) Mul that we have now
|
|
coeff, f = _keep_coeff(coeff, f.as_expr(), clear=False).as_coeff_Mul()
|
|
return _keep_coeff(coeff, term*f, clear=False)
|
|
|
|
|
|
@public
|
|
def trunc(f, p, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('trunc', 1, exc)
|
|
|
|
result = F.trunc(sympify(p))
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def monic(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('monic', 1, exc)
|
|
|
|
result = F.monic(auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def content(f, *gens, **args):
|
|
"""
|
|
Compute GCD of coefficients of ``f``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import content
|
|
>>> from sympy.abc import x
|
|
|
|
>>> content(6*x**2 + 8*x + 12)
|
|
2
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('content', 1, exc)
|
|
|
|
return F.content()
|
|
|
|
|
|
@public
|
|
def primitive(f, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('primitive', 1, exc)
|
|
|
|
cont, result = F.primitive()
|
|
if not opt.polys:
|
|
return cont, result.as_expr()
|
|
else:
|
|
return cont, result
|
|
|
|
|
|
@public
|
|
def compose(f, g, *gens, **args):
|
|
"""
|
|
Compute functional composition ``f(g)``.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import compose
|
|
>>> from sympy.abc import x
|
|
|
|
>>> compose(x**2 + x, x - 1)
|
|
x**2 - x
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
(F, G), opt = parallel_poly_from_expr((f, g), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('compose', 2, exc)
|
|
|
|
result = F.compose(G)
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def decompose(f, *gens, **args):
|
|
"""
|
|
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]
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('decompose', 1, exc)
|
|
|
|
result = F.decompose()
|
|
|
|
if not opt.polys:
|
|
return [r.as_expr() for r in result]
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def sturm(f, *gens, **args):
|
|
"""
|
|
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]
|
|
|
|
"""
|
|
options.allowed_flags(args, ['auto', 'polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('sturm', 1, exc)
|
|
|
|
result = F.sturm(auto=opt.auto)
|
|
|
|
if not opt.polys:
|
|
return [r.as_expr() for r in result]
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def gff_list(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('gff_list', 1, exc)
|
|
|
|
factors = F.gff_list()
|
|
|
|
if not opt.polys:
|
|
return [(g.as_expr(), k) for g, k in factors]
|
|
else:
|
|
return factors
|
|
|
|
|
|
@public
|
|
def gff(f, *gens, **args):
|
|
"""Compute greatest factorial factorization of ``f``. """
|
|
raise NotImplementedError('symbolic falling factorial')
|
|
|
|
|
|
@public
|
|
def sqf_norm(f, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('sqf_norm', 1, exc)
|
|
|
|
s, g, r = F.sqf_norm()
|
|
|
|
if not opt.polys:
|
|
return Integer(s), g.as_expr(), r.as_expr()
|
|
else:
|
|
return Integer(s), g, r
|
|
|
|
|
|
@public
|
|
def sqf_part(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('sqf_part', 1, exc)
|
|
|
|
result = F.sqf_part()
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
def _sorted_factors(factors, method):
|
|
"""Sort a list of ``(expr, exp)`` pairs. """
|
|
if method == 'sqf':
|
|
def key(obj):
|
|
poly, exp = obj
|
|
rep = poly.rep.rep
|
|
return (exp, len(rep), len(poly.gens), str(poly.domain), rep)
|
|
else:
|
|
def key(obj):
|
|
poly, exp = obj
|
|
rep = poly.rep.rep
|
|
return (len(rep), len(poly.gens), exp, str(poly.domain), rep)
|
|
|
|
return sorted(factors, key=key)
|
|
|
|
|
|
def _factors_product(factors):
|
|
"""Multiply a list of ``(expr, exp)`` pairs. """
|
|
return Mul(*[f.as_expr()**k for f, k in factors])
|
|
|
|
|
|
def _symbolic_factor_list(expr, opt, method):
|
|
"""Helper function for :func:`_symbolic_factor`. """
|
|
coeff, factors = S.One, []
|
|
|
|
args = [i._eval_factor() if hasattr(i, '_eval_factor') else i
|
|
for i in Mul.make_args(expr)]
|
|
for arg in args:
|
|
if arg.is_Number or (isinstance(arg, Expr) and pure_complex(arg)):
|
|
coeff *= arg
|
|
continue
|
|
elif arg.is_Pow and arg.base != S.Exp1:
|
|
base, exp = arg.args
|
|
if base.is_Number and exp.is_Number:
|
|
coeff *= arg
|
|
continue
|
|
if base.is_Number:
|
|
factors.append((base, exp))
|
|
continue
|
|
else:
|
|
base, exp = arg, S.One
|
|
|
|
try:
|
|
poly, _ = _poly_from_expr(base, opt)
|
|
except PolificationFailed as exc:
|
|
factors.append((exc.expr, exp))
|
|
else:
|
|
func = getattr(poly, method + '_list')
|
|
|
|
_coeff, _factors = func()
|
|
if _coeff is not S.One:
|
|
if exp.is_Integer:
|
|
coeff *= _coeff**exp
|
|
elif _coeff.is_positive:
|
|
factors.append((_coeff, exp))
|
|
else:
|
|
_factors.append((_coeff, S.One))
|
|
|
|
if exp is S.One:
|
|
factors.extend(_factors)
|
|
elif exp.is_integer:
|
|
factors.extend([(f, k*exp) for f, k in _factors])
|
|
else:
|
|
other = []
|
|
|
|
for f, k in _factors:
|
|
if f.as_expr().is_positive:
|
|
factors.append((f, k*exp))
|
|
else:
|
|
other.append((f, k))
|
|
|
|
factors.append((_factors_product(other), exp))
|
|
if method == 'sqf':
|
|
factors = [(reduce(mul, (f for f, _ in factors if _ == k)), k)
|
|
for k in {i for _, i in factors}]
|
|
|
|
return coeff, factors
|
|
|
|
|
|
def _symbolic_factor(expr, opt, method):
|
|
"""Helper function for :func:`_factor`. """
|
|
if isinstance(expr, Expr):
|
|
if hasattr(expr,'_eval_factor'):
|
|
return expr._eval_factor()
|
|
coeff, factors = _symbolic_factor_list(together(expr, fraction=opt['fraction']), opt, method)
|
|
return _keep_coeff(coeff, _factors_product(factors))
|
|
elif hasattr(expr, 'args'):
|
|
return expr.func(*[_symbolic_factor(arg, opt, method) for arg in expr.args])
|
|
elif hasattr(expr, '__iter__'):
|
|
return expr.__class__([_symbolic_factor(arg, opt, method) for arg in expr])
|
|
else:
|
|
return expr
|
|
|
|
|
|
def _generic_factor_list(expr, gens, args, method):
|
|
"""Helper function for :func:`sqf_list` and :func:`factor_list`. """
|
|
options.allowed_flags(args, ['frac', 'polys'])
|
|
opt = options.build_options(gens, args)
|
|
|
|
expr = sympify(expr)
|
|
|
|
if isinstance(expr, (Expr, Poly)):
|
|
if isinstance(expr, Poly):
|
|
numer, denom = expr, 1
|
|
else:
|
|
numer, denom = together(expr).as_numer_denom()
|
|
|
|
cp, fp = _symbolic_factor_list(numer, opt, method)
|
|
cq, fq = _symbolic_factor_list(denom, opt, method)
|
|
|
|
if fq and not opt.frac:
|
|
raise PolynomialError("a polynomial expected, got %s" % expr)
|
|
|
|
_opt = opt.clone({"expand": True})
|
|
|
|
for factors in (fp, fq):
|
|
for i, (f, k) in enumerate(factors):
|
|
if not f.is_Poly:
|
|
f, _ = _poly_from_expr(f, _opt)
|
|
factors[i] = (f, k)
|
|
|
|
fp = _sorted_factors(fp, method)
|
|
fq = _sorted_factors(fq, method)
|
|
|
|
if not opt.polys:
|
|
fp = [(f.as_expr(), k) for f, k in fp]
|
|
fq = [(f.as_expr(), k) for f, k in fq]
|
|
|
|
coeff = cp/cq
|
|
|
|
if not opt.frac:
|
|
return coeff, fp
|
|
else:
|
|
return coeff, fp, fq
|
|
else:
|
|
raise PolynomialError("a polynomial expected, got %s" % expr)
|
|
|
|
|
|
def _generic_factor(expr, gens, args, method):
|
|
"""Helper function for :func:`sqf` and :func:`factor`. """
|
|
fraction = args.pop('fraction', True)
|
|
options.allowed_flags(args, [])
|
|
opt = options.build_options(gens, args)
|
|
opt['fraction'] = fraction
|
|
return _symbolic_factor(sympify(expr), opt, method)
|
|
|
|
|
|
def to_rational_coeffs(f):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
from sympy.simplify.simplify import simplify
|
|
|
|
def _try_rescale(f, f1=None):
|
|
"""
|
|
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``.
|
|
"""
|
|
if not len(f.gens) == 1 or not (f.gens[0]).is_Atom:
|
|
return None, f
|
|
n = f.degree()
|
|
lc = f.LC()
|
|
f1 = f1 or f1.monic()
|
|
coeffs = f1.all_coeffs()[1:]
|
|
coeffs = [simplify(coeffx) for coeffx in coeffs]
|
|
if len(coeffs) > 1 and coeffs[-2]:
|
|
rescale1_x = simplify(coeffs[-2]/coeffs[-1])
|
|
coeffs1 = []
|
|
for i in range(len(coeffs)):
|
|
coeffx = simplify(coeffs[i]*rescale1_x**(i + 1))
|
|
if not coeffx.is_rational:
|
|
break
|
|
coeffs1.append(coeffx)
|
|
else:
|
|
rescale_x = simplify(1/rescale1_x)
|
|
x = f.gens[0]
|
|
v = [x**n]
|
|
for i in range(1, n + 1):
|
|
v.append(coeffs1[i - 1]*x**(n - i))
|
|
f = Add(*v)
|
|
f = Poly(f)
|
|
return lc, rescale_x, f
|
|
return None
|
|
|
|
def _try_translate(f, f1=None):
|
|
"""
|
|
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``.
|
|
"""
|
|
if not len(f.gens) == 1 or not (f.gens[0]).is_Atom:
|
|
return None, f
|
|
n = f.degree()
|
|
f1 = f1 or f1.monic()
|
|
coeffs = f1.all_coeffs()[1:]
|
|
c = simplify(coeffs[0])
|
|
if c.is_Add and not c.is_rational:
|
|
rat, nonrat = sift(c.args,
|
|
lambda z: z.is_rational is True, binary=True)
|
|
alpha = -c.func(*nonrat)/n
|
|
f2 = f1.shift(alpha)
|
|
return alpha, f2
|
|
return None
|
|
|
|
def _has_square_roots(p):
|
|
"""
|
|
Return True if ``f`` is a sum with square roots but no other root
|
|
"""
|
|
coeffs = p.coeffs()
|
|
has_sq = False
|
|
for y in coeffs:
|
|
for x in Add.make_args(y):
|
|
f = Factors(x).factors
|
|
r = [wx.q for b, wx in f.items() if
|
|
b.is_number and wx.is_Rational and wx.q >= 2]
|
|
if not r:
|
|
continue
|
|
if min(r) == 2:
|
|
has_sq = True
|
|
if max(r) > 2:
|
|
return False
|
|
return has_sq
|
|
|
|
if f.get_domain().is_EX and _has_square_roots(f):
|
|
f1 = f.monic()
|
|
r = _try_rescale(f, f1)
|
|
if r:
|
|
return r[0], r[1], None, r[2]
|
|
else:
|
|
r = _try_translate(f, f1)
|
|
if r:
|
|
return None, None, r[0], r[1]
|
|
return None
|
|
|
|
|
|
def _torational_factor_list(p, x):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
from sympy.simplify.simplify import simplify
|
|
p1 = Poly(p, x, domain='EX')
|
|
n = p1.degree()
|
|
res = to_rational_coeffs(p1)
|
|
if not res:
|
|
return None
|
|
lc, r, t, g = res
|
|
factors = factor_list(g.as_expr())
|
|
if lc:
|
|
c = simplify(factors[0]*lc*r**n)
|
|
r1 = simplify(1/r)
|
|
a = []
|
|
for z in factors[1:][0]:
|
|
a.append((simplify(z[0].subs({x: x*r1})), z[1]))
|
|
else:
|
|
c = factors[0]
|
|
a = []
|
|
for z in factors[1:][0]:
|
|
a.append((z[0].subs({x: x - t}), z[1]))
|
|
return (c, a)
|
|
|
|
|
|
@public
|
|
def sqf_list(f, *gens, **args):
|
|
"""
|
|
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)])
|
|
|
|
"""
|
|
return _generic_factor_list(f, gens, args, method='sqf')
|
|
|
|
|
|
@public
|
|
def sqf(f, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return _generic_factor(f, gens, args, method='sqf')
|
|
|
|
|
|
@public
|
|
def factor_list(f, *gens, **args):
|
|
"""
|
|
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)])
|
|
|
|
"""
|
|
return _generic_factor_list(f, gens, args, method='factor')
|
|
|
|
|
|
@public
|
|
def factor(f, *gens, deep=False, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
f = sympify(f)
|
|
if deep:
|
|
def _try_factor(expr):
|
|
"""
|
|
Factor, but avoid changing the expression when unable to.
|
|
"""
|
|
fac = factor(expr, *gens, **args)
|
|
if fac.is_Mul or fac.is_Pow:
|
|
return fac
|
|
return expr
|
|
|
|
f = bottom_up(f, _try_factor)
|
|
# clean up any subexpressions that may have been expanded
|
|
# while factoring out a larger expression
|
|
partials = {}
|
|
muladd = f.atoms(Mul, Add)
|
|
for p in muladd:
|
|
fac = factor(p, *gens, **args)
|
|
if (fac.is_Mul or fac.is_Pow) and fac != p:
|
|
partials[p] = fac
|
|
return f.xreplace(partials)
|
|
|
|
try:
|
|
return _generic_factor(f, gens, args, method='factor')
|
|
except PolynomialError as msg:
|
|
if not f.is_commutative:
|
|
return factor_nc(f)
|
|
else:
|
|
raise PolynomialError(msg)
|
|
|
|
|
|
@public
|
|
def intervals(F, all=False, eps=None, inf=None, sup=None, strict=False, fast=False, sqf=False):
|
|
"""
|
|
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)]
|
|
|
|
"""
|
|
if not hasattr(F, '__iter__'):
|
|
try:
|
|
F = Poly(F)
|
|
except GeneratorsNeeded:
|
|
return []
|
|
|
|
return F.intervals(all=all, eps=eps, inf=inf, sup=sup, fast=fast, sqf=sqf)
|
|
else:
|
|
polys, opt = parallel_poly_from_expr(F, domain='QQ')
|
|
|
|
if len(opt.gens) > 1:
|
|
raise MultivariatePolynomialError
|
|
|
|
for i, poly in enumerate(polys):
|
|
polys[i] = poly.rep.rep
|
|
|
|
if eps is not None:
|
|
eps = opt.domain.convert(eps)
|
|
|
|
if eps <= 0:
|
|
raise ValueError("'eps' must be a positive rational")
|
|
|
|
if inf is not None:
|
|
inf = opt.domain.convert(inf)
|
|
if sup is not None:
|
|
sup = opt.domain.convert(sup)
|
|
|
|
intervals = dup_isolate_real_roots_list(polys, opt.domain,
|
|
eps=eps, inf=inf, sup=sup, strict=strict, fast=fast)
|
|
|
|
result = []
|
|
|
|
for (s, t), indices in intervals:
|
|
s, t = opt.domain.to_sympy(s), opt.domain.to_sympy(t)
|
|
result.append(((s, t), indices))
|
|
|
|
return result
|
|
|
|
|
|
@public
|
|
def refine_root(f, s, t, eps=None, steps=None, fast=False, check_sqf=False):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
try:
|
|
F = Poly(f)
|
|
if not isinstance(f, Poly) and not F.gen.is_Symbol:
|
|
# root of sin(x) + 1 is -1 but when someone
|
|
# passes an Expr instead of Poly they may not expect
|
|
# that the generator will be sin(x), not x
|
|
raise PolynomialError("generator must be a Symbol")
|
|
except GeneratorsNeeded:
|
|
raise PolynomialError(
|
|
"Cannot refine a root of %s, not a polynomial" % f)
|
|
|
|
return F.refine_root(s, t, eps=eps, steps=steps, fast=fast, check_sqf=check_sqf)
|
|
|
|
|
|
@public
|
|
def count_roots(f, inf=None, sup=None):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
try:
|
|
F = Poly(f, greedy=False)
|
|
if not isinstance(f, Poly) and not F.gen.is_Symbol:
|
|
# root of sin(x) + 1 is -1 but when someone
|
|
# passes an Expr instead of Poly they may not expect
|
|
# that the generator will be sin(x), not x
|
|
raise PolynomialError("generator must be a Symbol")
|
|
except GeneratorsNeeded:
|
|
raise PolynomialError("Cannot count roots of %s, not a polynomial" % f)
|
|
|
|
return F.count_roots(inf=inf, sup=sup)
|
|
|
|
|
|
@public
|
|
def real_roots(f, multiple=True):
|
|
"""
|
|
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]
|
|
"""
|
|
try:
|
|
F = Poly(f, greedy=False)
|
|
if not isinstance(f, Poly) and not F.gen.is_Symbol:
|
|
# root of sin(x) + 1 is -1 but when someone
|
|
# passes an Expr instead of Poly they may not expect
|
|
# that the generator will be sin(x), not x
|
|
raise PolynomialError("generator must be a Symbol")
|
|
except GeneratorsNeeded:
|
|
raise PolynomialError(
|
|
"Cannot compute real roots of %s, not a polynomial" % f)
|
|
|
|
return F.real_roots(multiple=multiple)
|
|
|
|
|
|
@public
|
|
def nroots(f, n=15, maxsteps=50, cleanup=True):
|
|
"""
|
|
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]
|
|
|
|
"""
|
|
try:
|
|
F = Poly(f, greedy=False)
|
|
if not isinstance(f, Poly) and not F.gen.is_Symbol:
|
|
# root of sin(x) + 1 is -1 but when someone
|
|
# passes an Expr instead of Poly they may not expect
|
|
# that the generator will be sin(x), not x
|
|
raise PolynomialError("generator must be a Symbol")
|
|
except GeneratorsNeeded:
|
|
raise PolynomialError(
|
|
"Cannot compute numerical roots of %s, not a polynomial" % f)
|
|
|
|
return F.nroots(n=n, maxsteps=maxsteps, cleanup=cleanup)
|
|
|
|
|
|
@public
|
|
def ground_roots(f, *gens, **args):
|
|
"""
|
|
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}
|
|
|
|
"""
|
|
options.allowed_flags(args, [])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
if not isinstance(f, Poly) and not F.gen.is_Symbol:
|
|
# root of sin(x) + 1 is -1 but when someone
|
|
# passes an Expr instead of Poly they may not expect
|
|
# that the generator will be sin(x), not x
|
|
raise PolynomialError("generator must be a Symbol")
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('ground_roots', 1, exc)
|
|
|
|
return F.ground_roots()
|
|
|
|
|
|
@public
|
|
def nth_power_roots_poly(f, n, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
options.allowed_flags(args, [])
|
|
|
|
try:
|
|
F, opt = poly_from_expr(f, *gens, **args)
|
|
if not isinstance(f, Poly) and not F.gen.is_Symbol:
|
|
# root of sin(x) + 1 is -1 but when someone
|
|
# passes an Expr instead of Poly they may not expect
|
|
# that the generator will be sin(x), not x
|
|
raise PolynomialError("generator must be a Symbol")
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('nth_power_roots_poly', 1, exc)
|
|
|
|
result = F.nth_power_roots_poly(n)
|
|
|
|
if not opt.polys:
|
|
return result.as_expr()
|
|
else:
|
|
return result
|
|
|
|
|
|
@public
|
|
def cancel(f, *gens, _signsimp=True, **args):
|
|
"""
|
|
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
|
|
"""
|
|
from sympy.simplify.simplify import signsimp
|
|
from sympy.polys.rings import sring
|
|
options.allowed_flags(args, ['polys'])
|
|
|
|
f = sympify(f)
|
|
if _signsimp:
|
|
f = signsimp(f)
|
|
opt = {}
|
|
if 'polys' in args:
|
|
opt['polys'] = args['polys']
|
|
|
|
if not isinstance(f, (tuple, Tuple)):
|
|
if f.is_Number or isinstance(f, Relational) or not isinstance(f, Expr):
|
|
return f
|
|
f = factor_terms(f, radical=True)
|
|
p, q = f.as_numer_denom()
|
|
|
|
elif len(f) == 2:
|
|
p, q = f
|
|
if isinstance(p, Poly) and isinstance(q, Poly):
|
|
opt['gens'] = p.gens
|
|
opt['domain'] = p.domain
|
|
opt['polys'] = opt.get('polys', True)
|
|
p, q = p.as_expr(), q.as_expr()
|
|
elif isinstance(f, Tuple):
|
|
return factor_terms(f)
|
|
else:
|
|
raise ValueError('unexpected argument: %s' % f)
|
|
|
|
from sympy.functions.elementary.piecewise import Piecewise
|
|
try:
|
|
if f.has(Piecewise):
|
|
raise PolynomialError()
|
|
R, (F, G) = sring((p, q), *gens, **args)
|
|
if not R.ngens:
|
|
if not isinstance(f, (tuple, Tuple)):
|
|
return f.expand()
|
|
else:
|
|
return S.One, p, q
|
|
except PolynomialError as msg:
|
|
if f.is_commutative and not f.has(Piecewise):
|
|
raise PolynomialError(msg)
|
|
# Handling of noncommutative and/or piecewise expressions
|
|
if f.is_Add or f.is_Mul:
|
|
c, nc = sift(f.args, lambda x:
|
|
x.is_commutative is True and not x.has(Piecewise),
|
|
binary=True)
|
|
nc = [cancel(i) for i in nc]
|
|
return f.func(cancel(f.func(*c)), *nc)
|
|
else:
|
|
reps = []
|
|
pot = preorder_traversal(f)
|
|
next(pot)
|
|
for e in pot:
|
|
# XXX: This should really skip anything that's not Expr.
|
|
if isinstance(e, (tuple, Tuple, BooleanAtom)):
|
|
continue
|
|
try:
|
|
reps.append((e, cancel(e)))
|
|
pot.skip() # this was handled successfully
|
|
except NotImplementedError:
|
|
pass
|
|
return f.xreplace(dict(reps))
|
|
|
|
c, (P, Q) = 1, F.cancel(G)
|
|
if opt.get('polys', False) and 'gens' not in opt:
|
|
opt['gens'] = R.symbols
|
|
|
|
if not isinstance(f, (tuple, Tuple)):
|
|
return c*(P.as_expr()/Q.as_expr())
|
|
else:
|
|
P, Q = P.as_expr(), Q.as_expr()
|
|
if not opt.get('polys', False):
|
|
return c, P, Q
|
|
else:
|
|
return c, Poly(P, *gens, **opt), Poly(Q, *gens, **opt)
|
|
|
|
|
|
@public
|
|
def reduced(f, G, *gens, **args):
|
|
"""
|
|
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)
|
|
|
|
"""
|
|
options.allowed_flags(args, ['polys', 'auto'])
|
|
|
|
try:
|
|
polys, opt = parallel_poly_from_expr([f] + list(G), *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('reduced', 0, exc)
|
|
|
|
domain = opt.domain
|
|
retract = False
|
|
|
|
if opt.auto and domain.is_Ring and not domain.is_Field:
|
|
opt = opt.clone({"domain": domain.get_field()})
|
|
retract = True
|
|
|
|
from sympy.polys.rings import xring
|
|
_ring, _ = xring(opt.gens, opt.domain, opt.order)
|
|
|
|
for i, poly in enumerate(polys):
|
|
poly = poly.set_domain(opt.domain).rep.to_dict()
|
|
polys[i] = _ring.from_dict(poly)
|
|
|
|
Q, r = polys[0].div(polys[1:])
|
|
|
|
Q = [Poly._from_dict(dict(q), opt) for q in Q]
|
|
r = Poly._from_dict(dict(r), opt)
|
|
|
|
if retract:
|
|
try:
|
|
_Q, _r = [q.to_ring() for q in Q], r.to_ring()
|
|
except CoercionFailed:
|
|
pass
|
|
else:
|
|
Q, r = _Q, _r
|
|
|
|
if not opt.polys:
|
|
return [q.as_expr() for q in Q], r.as_expr()
|
|
else:
|
|
return Q, r
|
|
|
|
|
|
@public
|
|
def groebner(F, *gens, **args):
|
|
"""
|
|
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]_
|
|
|
|
"""
|
|
return GroebnerBasis(F, *gens, **args)
|
|
|
|
|
|
@public
|
|
def is_zero_dimensional(F, *gens, **args):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return GroebnerBasis(F, *gens, **args).is_zero_dimensional
|
|
|
|
|
|
@public
|
|
class GroebnerBasis(Basic):
|
|
"""Represents a reduced Groebner basis. """
|
|
|
|
def __new__(cls, F, *gens, **args):
|
|
"""Compute a reduced Groebner basis for a system of polynomials. """
|
|
options.allowed_flags(args, ['polys', 'method'])
|
|
|
|
try:
|
|
polys, opt = parallel_poly_from_expr(F, *gens, **args)
|
|
except PolificationFailed as exc:
|
|
raise ComputationFailed('groebner', len(F), exc)
|
|
|
|
from sympy.polys.rings import PolyRing
|
|
ring = PolyRing(opt.gens, opt.domain, opt.order)
|
|
|
|
polys = [ring.from_dict(poly.rep.to_dict()) for poly in polys if poly]
|
|
|
|
G = _groebner(polys, ring, method=opt.method)
|
|
G = [Poly._from_dict(g, opt) for g in G]
|
|
|
|
return cls._new(G, opt)
|
|
|
|
@classmethod
|
|
def _new(cls, basis, options):
|
|
obj = Basic.__new__(cls)
|
|
|
|
obj._basis = tuple(basis)
|
|
obj._options = options
|
|
|
|
return obj
|
|
|
|
@property
|
|
def args(self):
|
|
basis = (p.as_expr() for p in self._basis)
|
|
return (Tuple(*basis), Tuple(*self._options.gens))
|
|
|
|
@property
|
|
def exprs(self):
|
|
return [poly.as_expr() for poly in self._basis]
|
|
|
|
@property
|
|
def polys(self):
|
|
return list(self._basis)
|
|
|
|
@property
|
|
def gens(self):
|
|
return self._options.gens
|
|
|
|
@property
|
|
def domain(self):
|
|
return self._options.domain
|
|
|
|
@property
|
|
def order(self):
|
|
return self._options.order
|
|
|
|
def __len__(self):
|
|
return len(self._basis)
|
|
|
|
def __iter__(self):
|
|
if self._options.polys:
|
|
return iter(self.polys)
|
|
else:
|
|
return iter(self.exprs)
|
|
|
|
def __getitem__(self, item):
|
|
if self._options.polys:
|
|
basis = self.polys
|
|
else:
|
|
basis = self.exprs
|
|
|
|
return basis[item]
|
|
|
|
def __hash__(self):
|
|
return hash((self._basis, tuple(self._options.items())))
|
|
|
|
def __eq__(self, other):
|
|
if isinstance(other, self.__class__):
|
|
return self._basis == other._basis and self._options == other._options
|
|
elif iterable(other):
|
|
return self.polys == list(other) or self.exprs == list(other)
|
|
else:
|
|
return False
|
|
|
|
def __ne__(self, other):
|
|
return not self == other
|
|
|
|
@property
|
|
def is_zero_dimensional(self):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
def single_var(monomial):
|
|
return sum(map(bool, monomial)) == 1
|
|
|
|
exponents = Monomial([0]*len(self.gens))
|
|
order = self._options.order
|
|
|
|
for poly in self.polys:
|
|
monomial = poly.LM(order=order)
|
|
|
|
if single_var(monomial):
|
|
exponents *= monomial
|
|
|
|
# If any element of the exponents vector is zero, then there's
|
|
# a variable for which there's no degree bound and the ideal
|
|
# generated by this Groebner basis isn't zero-dimensional.
|
|
return all(exponents)
|
|
|
|
def fglm(self, order):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
opt = self._options
|
|
|
|
src_order = opt.order
|
|
dst_order = monomial_key(order)
|
|
|
|
if src_order == dst_order:
|
|
return self
|
|
|
|
if not self.is_zero_dimensional:
|
|
raise NotImplementedError("Cannot convert Groebner bases of ideals with positive dimension")
|
|
|
|
polys = list(self._basis)
|
|
domain = opt.domain
|
|
|
|
opt = opt.clone({
|
|
"domain": domain.get_field(),
|
|
"order": dst_order,
|
|
})
|
|
|
|
from sympy.polys.rings import xring
|
|
_ring, _ = xring(opt.gens, opt.domain, src_order)
|
|
|
|
for i, poly in enumerate(polys):
|
|
poly = poly.set_domain(opt.domain).rep.to_dict()
|
|
polys[i] = _ring.from_dict(poly)
|
|
|
|
G = matrix_fglm(polys, _ring, dst_order)
|
|
G = [Poly._from_dict(dict(g), opt) for g in G]
|
|
|
|
if not domain.is_Field:
|
|
G = [g.clear_denoms(convert=True)[1] for g in G]
|
|
opt.domain = domain
|
|
|
|
return self._new(G, opt)
|
|
|
|
def reduce(self, expr, auto=True):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
poly = Poly._from_expr(expr, self._options)
|
|
polys = [poly] + list(self._basis)
|
|
|
|
opt = self._options
|
|
domain = opt.domain
|
|
|
|
retract = False
|
|
|
|
if auto and domain.is_Ring and not domain.is_Field:
|
|
opt = opt.clone({"domain": domain.get_field()})
|
|
retract = True
|
|
|
|
from sympy.polys.rings import xring
|
|
_ring, _ = xring(opt.gens, opt.domain, opt.order)
|
|
|
|
for i, poly in enumerate(polys):
|
|
poly = poly.set_domain(opt.domain).rep.to_dict()
|
|
polys[i] = _ring.from_dict(poly)
|
|
|
|
Q, r = polys[0].div(polys[1:])
|
|
|
|
Q = [Poly._from_dict(dict(q), opt) for q in Q]
|
|
r = Poly._from_dict(dict(r), opt)
|
|
|
|
if retract:
|
|
try:
|
|
_Q, _r = [q.to_ring() for q in Q], r.to_ring()
|
|
except CoercionFailed:
|
|
pass
|
|
else:
|
|
Q, r = _Q, _r
|
|
|
|
if not opt.polys:
|
|
return [q.as_expr() for q in Q], r.as_expr()
|
|
else:
|
|
return Q, r
|
|
|
|
def contains(self, poly):
|
|
"""
|
|
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
|
|
|
|
"""
|
|
return self.reduce(poly)[1] == 0
|
|
|
|
|
|
@public
|
|
def poly(expr, *gens, **args):
|
|
"""
|
|
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')
|
|
|
|
"""
|
|
options.allowed_flags(args, [])
|
|
|
|
def _poly(expr, opt):
|
|
terms, poly_terms = [], []
|
|
|
|
for term in Add.make_args(expr):
|
|
factors, poly_factors = [], []
|
|
|
|
for factor in Mul.make_args(term):
|
|
if factor.is_Add:
|
|
poly_factors.append(_poly(factor, opt))
|
|
elif factor.is_Pow and factor.base.is_Add and \
|
|
factor.exp.is_Integer and factor.exp >= 0:
|
|
poly_factors.append(
|
|
_poly(factor.base, opt).pow(factor.exp))
|
|
else:
|
|
factors.append(factor)
|
|
|
|
if not poly_factors:
|
|
terms.append(term)
|
|
else:
|
|
product = poly_factors[0]
|
|
|
|
for factor in poly_factors[1:]:
|
|
product = product.mul(factor)
|
|
|
|
if factors:
|
|
factor = Mul(*factors)
|
|
|
|
if factor.is_Number:
|
|
product = product.mul(factor)
|
|
else:
|
|
product = product.mul(Poly._from_expr(factor, opt))
|
|
|
|
poly_terms.append(product)
|
|
|
|
if not poly_terms:
|
|
result = Poly._from_expr(expr, opt)
|
|
else:
|
|
result = poly_terms[0]
|
|
|
|
for term in poly_terms[1:]:
|
|
result = result.add(term)
|
|
|
|
if terms:
|
|
term = Add(*terms)
|
|
|
|
if term.is_Number:
|
|
result = result.add(term)
|
|
else:
|
|
result = result.add(Poly._from_expr(term, opt))
|
|
|
|
return result.reorder(*opt.get('gens', ()), **args)
|
|
|
|
expr = sympify(expr)
|
|
|
|
if expr.is_Poly:
|
|
return Poly(expr, *gens, **args)
|
|
|
|
if 'expand' not in args:
|
|
args['expand'] = False
|
|
|
|
opt = options.build_options(gens, args)
|
|
|
|
return _poly(expr, opt)
|
|
|
|
|
|
def named_poly(n, f, K, name, x, polys):
|
|
r"""Common 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.
|
|
"""
|
|
if n < 0:
|
|
raise ValueError("Cannot generate %s of index %s" % (name, n))
|
|
head, tail = x[0], x[1:]
|
|
if K is None:
|
|
K, tail = construct_domain(tail, field=True)
|
|
poly = DMP(f(int(n), *tail, K), K)
|
|
if head is None:
|
|
poly = PurePoly.new(poly, Dummy('x'))
|
|
else:
|
|
poly = Poly.new(poly, head)
|
|
return poly if polys else poly.as_expr()
|