def dmp_exquo(f, g, u, K):
"""
Returns polynomial quotient in ``K[X]``.
Examples
========
>>> from diofant.polys import ring, ZZ
>>> R, x,y = ring("x,y", ZZ)
>>> f = x**2 + x*y
>>> g = x + y
>>> h = 2*x + 2
>>> R.dmp_exquo(f, g)
x
>>> R.dmp_exquo(f, h)
Traceback (most recent call last):
...
ExactQuotientFailed: [[2], [2]] does not divide [[1], [1, 0], []]
"""
q, r = dmp_div(f, g, u, K)
if dmp_zero_p(r, u):
return q
else:
raise ExactQuotientFailed(f, g)
def test_printing():
f, g = [dmp_normal([], 0, EX)] * 2
e = PolynomialDivisionFailed(f, g, EX)
assert str(e)[:57] == ("couldn't reduce degree in a polynomial "
"division algorithm")
assert str(e)[-140:][:57] == ("You may want to use a different "
"simplification algorithm.")
f, g = [dmp_normal([], 0, RR)] * 2
e = PolynomialDivisionFailed(f, g, RR)
assert str(e)[-139:][:74] == ("Your working precision or tolerance of "
"computations may be set improperly.")
f, g = [dmp_normal([], 0, ZZ)] * 2
e = PolynomialDivisionFailed(f, g, ZZ)
assert str(e)[-168:][:80] == (
"Zero detection is guaranteed in this "
"coefficient domain. This may indicate a bug")
e = OperationNotSupported(Poly(x), 'spam')
assert str(e).find('spam') >= 0
assert str(e).find('operation not supported') >= 0
exc = PolificationFailed(1, x, x**2)
assert str(exc).find("can't construct a polynomial from x") >= 0
exc = PolificationFailed(1, [x], [x**2], True)
assert str(exc).find("can't construct polynomials from x") >= 0
e = ComputationFailed('LT', 1, exc)
assert str(e).find('failed without generators') >= 0
assert str(e).find('x**2') >= 0
e = ExactQuotientFailed(Poly(x), Poly(x**2))
assert str(e).find('does not divide') >= 0
assert str(e).find('x**2') >= 0
assert str(e).find('in ZZ') < 0
e = ExactQuotientFailed(Poly(x), Poly(x**2), ZZ)
assert str(e).find('in ZZ') >= 0
def __div__(self, other):
if isinstance(other, Monomial):
exponents = other.exponents
elif isinstance(other, (tuple, Tuple)):
exponents = other
else:
return NotImplementedError
result = monomial_div(self.exponents, exponents)
if result is not None:
return self.rebuild(result)
else:
raise ExactQuotientFailed(self, Monomial(other))
def gf_exquo(f, g, p, K):
"""
Compute polynomial quotient in ``GF(p)[x]``.
Examples
========
>>> from diofant.polys.domains import ZZ
>>> gf_exquo(ZZ.map([1, 0, 3, 2, 3]), ZZ.map([2, 2, 2]), 5, ZZ)
[3, 2, 4]
>>> gf_exquo(ZZ.map([1, 0, 1, 1]), ZZ.map([1, 1, 0]), 2, ZZ)
Traceback (most recent call last):
...
ExactQuotientFailed: [1, 1, 0] does not divide [1, 0, 1, 1]
"""
q, r = gf_div(f, g, p, K)
if not r:
return q
else:
raise ExactQuotientFailed(f, g)
def dup_exquo(f, g, K):
"""
Returns polynomial quotient in ``K[x]``.
Examples
========
>>> from diofant.polys import ring, ZZ
>>> R, x = ring("x", ZZ)
>>> R.dup_exquo(x**2 - 1, x - 1)
x + 1
>>> R.dup_exquo(x**2 + 1, 2*x - 4)
Traceback (most recent call last):
...
ExactQuotientFailed: [2, -4] does not divide [1, 0, 1]
"""
q, r = dup_div(f, g, K)
if not r:
return q
else:
raise ExactQuotientFailed(f, g)
def exquo(self, a, b):
"""Exact quotient of ``a`` and ``b``, implies ``__floordiv__``. """
if a % b:
raise ExactQuotientFailed(a, b, self)
else:
return a // b