def test__dict_from_expr_no_gens():
pytest.raises(GeneratorsNeeded, lambda: dict_from_expr(Integer(17)))
assert dict_from_expr(x) == ({(1, ): 1}, (x, ))
assert dict_from_expr(y) == ({(1, ): 1}, (y, ))
assert dict_from_expr(x * y) == ({(1, 1): 1}, (x, y))
assert dict_from_expr(x + y) == ({(1, 0): 1, (0, 1): 1}, (x, y))
assert dict_from_expr(sqrt(2)) == ({(1, ): 1}, (sqrt(2), ))
pytest.raises(GeneratorsNeeded,
lambda: dict_from_expr(sqrt(2), greedy=False))
assert dict_from_expr(x * y, domain=ZZ.poly_ring(x)) == ({(1, ): x}, (y, ))
assert dict_from_expr(x * y, domain=ZZ.poly_ring(y)) == ({(1, ): y}, (x, ))
assert dict_from_expr(3 * sqrt(2) * pi * x * y, extension=None) == ({
(1, 1, 1, 1):
3
}, (x, y, pi, sqrt(2)))
assert dict_from_expr(3 * sqrt(2) * pi * x * y, extension=True) == ({
(1, 1, 1):
3 * sqrt(2)
}, (x, y, pi))
f = cos(x) * sin(x) + cos(x) * sin(y) + cos(y) * sin(x) + cos(y) * sin(y)
assert dict_from_expr(f) == ({
(0, 1, 0, 1): 1,
(0, 1, 1, 0): 1,
(1, 0, 0, 1): 1,
(1, 0, 1, 0): 1
}, (cos(x), cos(y), sin(x), sin(y)))
def test_PolynomialRing():
sT(ZZ.poly_ring("x"), "PolynomialRing(%s, (Symbol('x'),), "
"LexOrder())" % repr(ZZ))
sT(QQ.poly_ring("x", "y", order=grlex),
"PolynomialRing(%s, (Symbol('x'), Symbol('y')), "
"GradedLexOrder())" % repr(QQ))
sT(ZZ.poly_ring("t").poly_ring("x", "y", "z"),
"PolynomialRing(PolynomialRing(%s, (Symbol('t'),), "
"LexOrder()), (Symbol('x'), Symbol('y'), Symbol('z')), "
"LexOrder())" % repr(ZZ))
def test_Domain___eq__():
assert (ZZ.poly_ring(x, y) == ZZ.poly_ring(x, y)) is True
assert (QQ.poly_ring(x, y) == QQ.poly_ring(x, y)) is True
assert (ZZ.poly_ring(x, y) == QQ.poly_ring(x, y)) is False
assert (QQ.poly_ring(x, y) == ZZ.poly_ring(x, y)) is False
assert (ZZ.frac_field(x, y) == ZZ.frac_field(x, y)) is True
assert (QQ.frac_field(x, y) == QQ.frac_field(x, y)) is True
assert (ZZ.frac_field(x, y) == QQ.frac_field(x, y)) is False
assert (QQ.frac_field(x, y) == ZZ.frac_field(x, y)) is False
def test_Domain___eq__():
assert (ZZ.poly_ring(x, y) == ZZ.poly_ring(x, y)) is True
assert (QQ.poly_ring(x, y) == QQ.poly_ring(x, y)) is True
assert (ZZ.poly_ring(x, y) == QQ.poly_ring(x, y)) is False
assert (QQ.poly_ring(x, y) == ZZ.poly_ring(x, y)) is False
assert (ZZ.frac_field(x, y) == ZZ.frac_field(x, y)) is True
assert (QQ.frac_field(x, y) == QQ.frac_field(x, y)) is True
assert (ZZ.frac_field(x, y) == QQ.frac_field(x, y)) is False
assert (QQ.frac_field(x, y) == ZZ.frac_field(x, y)) is False
def test_PolynomialRing():
sT(ZZ.poly_ring("x"), "PolynomialRing(%s, (Symbol('x'),), "
"LexOrder())" % repr(ZZ))
sT(
QQ.poly_ring("x", "y", order=grlex),
"PolynomialRing(%s, (Symbol('x'), Symbol('y')), "
"GradedLexOrder())" % repr(QQ))
sT(
ZZ.poly_ring("t").poly_ring("x", "y", "z"),
"PolynomialRing(PolynomialRing(%s, (Symbol('t'),), "
"LexOrder()), (Symbol('x'), Symbol('y'), Symbol('z')), "
"LexOrder())" % repr(ZZ))
def test_Domain_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ.poly_ring(x).has_assoc_Ring is True
assert QQ.poly_ring(x).has_assoc_Ring is True
assert ZZ.poly_ring(x, y).has_assoc_Ring is True
assert QQ.poly_ring(x, y).has_assoc_Ring is True
assert ZZ.frac_field(x).has_assoc_Ring is True
assert QQ.frac_field(x).has_assoc_Ring is True
assert ZZ.frac_field(x, y).has_assoc_Ring is True
assert QQ.frac_field(x, y).has_assoc_Ring is True
assert EX.has_assoc_Ring is False
assert RR.has_assoc_Ring is False
assert ALG.has_assoc_Ring is False
assert ZZ.ring == ZZ
assert QQ.ring == ZZ
assert ZZ.poly_ring(x).ring == ZZ.poly_ring(x)
assert QQ.poly_ring(x).ring == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).ring == ZZ.poly_ring(x, y)
assert QQ.poly_ring(x, y).ring == QQ.poly_ring(x, y)
assert ZZ.frac_field(x).ring == ZZ.poly_ring(x)
assert QQ.frac_field(x).ring == QQ.poly_ring(x)
assert ZZ.frac_field(x, y).ring == ZZ.poly_ring(x, y)
assert QQ.frac_field(x, y).ring == QQ.poly_ring(x, y)
assert EX.ring == EX
pytest.raises(AttributeError, lambda: RR.ring)
pytest.raises(AttributeError, lambda: ALG.ring)
def test_Domain_get_exact():
assert EX.get_exact() == EX
assert ZZ.get_exact() == ZZ
assert QQ.get_exact() == QQ
assert RR.get_exact() == QQ
assert ALG.get_exact() == ALG
assert ZZ.poly_ring(x).get_exact() == ZZ.poly_ring(x)
assert QQ.poly_ring(x).get_exact() == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).get_exact() == ZZ.poly_ring(x, y)
assert QQ.poly_ring(x, y).get_exact() == QQ.poly_ring(x, y)
assert ZZ.frac_field(x).get_exact() == ZZ.frac_field(x)
assert QQ.frac_field(x).get_exact() == QQ.frac_field(x)
assert ZZ.frac_field(x, y).get_exact() == ZZ.frac_field(x, y)
assert QQ.frac_field(x, y).get_exact() == QQ.frac_field(x, y)
def test_Domain_get_exact():
assert EX.get_exact() == EX
assert ZZ.get_exact() == ZZ
assert QQ.get_exact() == QQ
assert RR.get_exact() == QQ
assert ALG.get_exact() == ALG
assert ZZ.poly_ring(x).get_exact() == ZZ.poly_ring(x)
assert QQ.poly_ring(x).get_exact() == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).get_exact() == ZZ.poly_ring(x, y)
assert QQ.poly_ring(x, y).get_exact() == QQ.poly_ring(x, y)
assert ZZ.frac_field(x).get_exact() == ZZ.frac_field(x)
assert QQ.frac_field(x).get_exact() == QQ.frac_field(x)
assert ZZ.frac_field(x, y).get_exact() == ZZ.frac_field(x, y)
assert QQ.frac_field(x, y).get_exact() == QQ.frac_field(x, y)
def test_Domain_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ.poly_ring(x).has_assoc_Ring is True
assert QQ.poly_ring(x).has_assoc_Ring is True
assert ZZ.poly_ring(x, y).has_assoc_Ring is True
assert QQ.poly_ring(x, y).has_assoc_Ring is True
assert ZZ.frac_field(x).has_assoc_Ring is True
assert QQ.frac_field(x).has_assoc_Ring is True
assert ZZ.frac_field(x, y).has_assoc_Ring is True
assert QQ.frac_field(x, y).has_assoc_Ring is True
assert EX.has_assoc_Ring is False
assert RR.has_assoc_Ring is False
assert ALG.has_assoc_Ring is False
assert ZZ.ring == ZZ
assert QQ.ring == ZZ
assert ZZ.poly_ring(x).ring == ZZ.poly_ring(x)
assert QQ.poly_ring(x).ring == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).ring == ZZ.poly_ring(x, y)
assert QQ.poly_ring(x, y).ring == QQ.poly_ring(x, y)
assert ZZ.frac_field(x).ring == ZZ.poly_ring(x)
assert QQ.frac_field(x).ring == QQ.poly_ring(x)
assert ZZ.frac_field(x, y).ring == ZZ.poly_ring(x, y)
assert QQ.frac_field(x, y).ring == QQ.poly_ring(x, y)
assert EX.ring == EX
pytest.raises(AttributeError, lambda: RR.ring)
pytest.raises(AttributeError, lambda: ALG.ring)
def test_dup_cyclotomic_p():
R, x = ring("x", ZZ)
assert R.dup_cyclotomic_p(x - 1) is True
assert R.dup_cyclotomic_p(x + 1) is True
assert R.dup_cyclotomic_p(x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**2 + 1) is True
assert R.dup_cyclotomic_p(x**2 + 1, irreducible=True) is True
assert R.dup_cyclotomic_p(x**4 + x**3 + x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**2 - x + 1) is True
assert R.dup_cyclotomic_p(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**4 + 1) is True
assert R.dup_cyclotomic_p(x**6 + x**3 + 1) is True
assert R.dup_cyclotomic_p(0) is False
assert R.dup_cyclotomic_p(1) is False
assert R.dup_cyclotomic_p(x) is False
assert R.dup_cyclotomic_p(x + 2) is False
assert R.dup_cyclotomic_p(3 * x + 1) is False
assert R.dup_cyclotomic_p(x**2 - 1) is False
f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1
assert R.dup_cyclotomic_p(f) is False
g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1
assert R.dup_cyclotomic_p(g) is True
R, x = ring("x", QQ)
assert R.dup_cyclotomic_p(x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**2 / 2 + x + 1) is False
R, x = ring("x", ZZ.poly_ring("y"))
assert R.dup_cyclotomic_p(x**2 + x + 1) is False
def test_Domain_postprocess():
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'gens': (x, y),
'domain': ZZ.poly_ring(y, z)}))
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'gens': (),
'domain': EX}))
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'domain': EX}))
def test_dup_cyclotomic_p():
R, x = ring("x", ZZ)
assert R.dup_cyclotomic_p(x - 1) is True
assert R.dup_cyclotomic_p(x + 1) is True
assert R.dup_cyclotomic_p(x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**2 + 1) is True
assert R.dup_cyclotomic_p(x**2 + 1, irreducible=True) is True
assert R.dup_cyclotomic_p(x**4 + x**3 + x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**2 - x + 1) is True
assert R.dup_cyclotomic_p(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**4 + 1) is True
assert R.dup_cyclotomic_p(x**6 + x**3 + 1) is True
assert R.dup_cyclotomic_p(0) is False
assert R.dup_cyclotomic_p(1) is False
assert R.dup_cyclotomic_p(x) is False
assert R.dup_cyclotomic_p(x + 2) is False
assert R.dup_cyclotomic_p(3*x + 1) is False
assert R.dup_cyclotomic_p(x**2 - 1) is False
f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1
assert R.dup_cyclotomic_p(f) is False
g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1
assert R.dup_cyclotomic_p(g) is True
R, x = ring("x", QQ)
assert R.dup_cyclotomic_p(x**2 + x + 1) is True
assert R.dup_cyclotomic_p(x**2/2 + x + 1) is False
R, x = ring("x", ZZ.poly_ring("y"))
assert R.dup_cyclotomic_p(x**2 + x + 1) is False
def test_localring():
Qxy = QQ.frac_field(x, y)
R = QQ.poly_ring(x, y, order="ilex")
X = R.convert(x)
Y = R.convert(y)
assert x in R
assert 1 / x not in R
assert Y in R
assert X.ring == R.ring
assert X + Y == R.convert(x + y)
assert X - Y == R.convert(x - y)
assert X + 1 == R.convert(x + 1)
assert X**2 // X == X
assert R.convert(ZZ.poly_ring(x, y).convert(x), ZZ.poly_ring(x, y)) == X
assert R.convert(Qxy.convert(x), Qxy) == X
def test_PolynomialRing_to_ground():
R, x = ring("x", ZZ)
pytest.raises(ValueError, lambda: R.to_ground())
R2, x, y = ring("x,y", ZZ)
assert R2.drop_to_ground(x) == ZZ.poly_ring("x").poly_ring("y")
assert R2.drop_to_ground(x, y) == R2
def test_PolyElement_drop():
R, x, y, z = ring("x,y,z", ZZ)
assert R(1).drop(0).ring == ZZ.poly_ring("y", "z")
assert R(1).drop(0).drop(0).ring == ZZ.poly_ring("z")
assert isinstance(R(1).drop(0).drop(0).drop(0), R.dtype) is False
pytest.raises(ValueError, lambda: z.drop(0).drop(0).drop(0))
pytest.raises(ValueError, lambda: x.drop(0))
f = z**2*x + 2*z*y + x*z + 1
R2 = R.drop_to_ground(z)
assert f.drop_to_ground(z) == z**2*R2.x + 2*z*R2.y + z*R2.x + 1
R3 = R.drop(y, z)
assert R3 == ZZ.poly_ring('x')
pytest.raises(ValueError, lambda: R3.x.drop_to_ground(R3.x))
def test_PolyElement_drop():
R, x, y, z = ring("x,y,z", ZZ)
assert R(1).drop(0).ring == ZZ.poly_ring("y", "z")
assert R(1).drop(0).drop(0).ring == ZZ.poly_ring("z")
assert isinstance(R(1).drop(0).drop(0).drop(0), R.dtype) is False
pytest.raises(ValueError, lambda: z.drop(0).drop(0).drop(0))
pytest.raises(ValueError, lambda: x.drop(0))
f = z**2*x + 2*z*y + x*z + 1
R2 = R.drop_to_ground(z)
assert f.drop_to_ground(z) == z**2*R2.x + 2*z*R2.y + z*R2.x + 1
R3 = R.drop(y, z)
assert R3 == ZZ.poly_ring('x')
pytest.raises(ValueError, lambda: R3.x.drop_to_ground(R3.x))
def test_PolynomialRing_to_ground():
R, x = ring("x", ZZ)
pytest.raises(ValueError, lambda: R.to_ground())
R2, x, y = ring("x,y", ZZ)
assert R2.drop_to_ground(x) == ZZ.poly_ring("x").poly_ring("y")
assert R2.drop_to_ground(x, y) == R2
def test_FractionField():
sT(ZZ.frac_field("x"), "FractionField(%s, (Symbol('x'),), "
"LexOrder())" % repr(ZZ))
sT(QQ.frac_field("x", "y", order=grlex),
"FractionField(%s, (Symbol('x'), Symbol('y')), "
"GradedLexOrder())" % repr(QQ))
sT(ZZ.poly_ring("t").frac_field("x", "y", "z"),
"FractionField(PolynomialRing(%s, (Symbol('t'),), LexOrder()), "
"(Symbol('x'), Symbol('y'), Symbol('z')), LexOrder())" % repr(ZZ))
def test___eq__():
assert not QQ.poly_ring(x) == ZZ.poly_ring(x)
assert not QQ.frac_field(x) == ZZ.frac_field(x)
assert EX(1) != EX(2)
F11 = FF(11)
assert F11(2) != F11(3)
assert F11(2) != object()
def test___eq__():
assert not QQ.poly_ring(x) == ZZ.poly_ring(x)
assert not QQ.frac_field(x) == ZZ.frac_field(x)
assert EX(1) != EX(2)
F11 = FF(11)
assert F11(2) != F11(3)
assert F11(2) != object()
def test_Domain_field():
assert EX.has_assoc_Field is True
assert ZZ.has_assoc_Field is True
assert QQ.has_assoc_Field is True
assert RR.has_assoc_Field is True
assert ALG.has_assoc_Field is True
assert ZZ.poly_ring(x).has_assoc_Field is True
assert QQ.poly_ring(x).has_assoc_Field is True
assert ZZ.poly_ring(x, y).has_assoc_Field is True
assert QQ.poly_ring(x, y).has_assoc_Field is True
assert EX.field == EX
assert ZZ.field == QQ
assert QQ.field == QQ
assert RR.field == RR
assert ALG.field == ALG
assert ZZ.poly_ring(x).field == ZZ.frac_field(x)
assert QQ.poly_ring(x).field == QQ.frac_field(x)
assert ZZ.poly_ring(x, y).field == ZZ.frac_field(x, y)
assert QQ.poly_ring(x, y).field == QQ.frac_field(x, y)
def test_Domain_field():
assert EX.has_assoc_Field is True
assert ZZ.has_assoc_Field is True
assert QQ.has_assoc_Field is True
assert RR.has_assoc_Field is True
assert ALG.has_assoc_Field is True
assert ZZ.poly_ring(x).has_assoc_Field is True
assert QQ.poly_ring(x).has_assoc_Field is True
assert ZZ.poly_ring(x, y).has_assoc_Field is True
assert QQ.poly_ring(x, y).has_assoc_Field is True
assert EX.field == EX
assert ZZ.field == QQ
assert QQ.field == QQ
assert RR.field == RR
assert ALG.field == ALG
assert ZZ.poly_ring(x).field == ZZ.frac_field(x)
assert QQ.poly_ring(x).field == QQ.frac_field(x)
assert ZZ.poly_ring(x, y).field == ZZ.frac_field(x, y)
assert QQ.poly_ring(x, y).field == QQ.frac_field(x, y)
def test_globalring():
Qxy = QQ.frac_field(x, y)
R = QQ.poly_ring(x, y)
X = R.convert(x)
Y = R.convert(y)
assert x in R
assert 1 / x not in R
assert 1 / (1 + x) not in R
assert Y in R
assert X.ring == R.ring
assert X * (Y**2 + 1) == R.convert(x * (y**2 + 1))
assert X * Y == R.convert(x * y)
assert X + Y == R.convert(x + y)
assert X - Y == R.convert(x - y)
assert X + 1 == R.convert(x + 1)
assert X**2 // X == X
assert R.convert(ZZ.poly_ring(x, y).convert(x), ZZ.poly_ring(x, y)) == X
assert R.convert(Qxy.convert(x), Qxy) == X
def test_FractionField():
sT(ZZ.frac_field("x"), "FractionField(%s, (Symbol('x'),), "
"LexOrder())" % repr(ZZ))
sT(
QQ.frac_field("x", "y", order=grlex),
"FractionField(%s, (Symbol('x'), Symbol('y')), "
"GradedLexOrder())" % repr(QQ))
sT(
ZZ.poly_ring("t").frac_field("x", "y", "z"),
"FractionField(PolynomialRing(%s, (Symbol('t'),), LexOrder()), "
"(Symbol('x'), Symbol('y'), Symbol('z')), LexOrder())" % repr(ZZ))
def test_Domain_postprocess():
pytest.raises(
GeneratorsError,
lambda: Domain.postprocess({
'gens': (x, y),
'domain': ZZ.poly_ring(y, z)
}))
pytest.raises(GeneratorsError, lambda: Domain.postprocess({
'gens': (),
'domain': EX
}))
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'domain': EX}))
def test_dmp_convert():
K0, K1 = ZZ.poly_ring('x'), ZZ
assert dmp_convert([K0(1), K0(2)], 0, K0, K1) == [ZZ(1), ZZ(2)]
assert dmp_convert([K1(1), K1(2)], 0, K1, K0) == [K0(1), K0(2)]
f = [K0(1), K0(2), K0(0), K0(3)]
assert dmp_convert(f, 0, K0, K1) == [ZZ(1), ZZ(2), ZZ(0), ZZ(3)]
f = [[K0(1)], [K0(2)], [], [K0(3)]]
assert dmp_convert(f, 1, K0, K1) == [[ZZ(1)], [ZZ(2)], [], [ZZ(3)]]
def test__dict_from_expr_no_gens():
pytest.raises(GeneratorsNeeded, lambda: dict_from_expr(Integer(17)))
assert dict_from_expr(x) == ({(1,): 1}, (x,))
assert dict_from_expr(y) == ({(1,): 1}, (y,))
assert dict_from_expr(x*y) == ({(1, 1): 1}, (x, y))
assert dict_from_expr(x + y) == ({(1, 0): 1, (0, 1): 1}, (x, y))
assert dict_from_expr(sqrt(2)) == ({(1,): 1}, (sqrt(2),))
pytest.raises(GeneratorsNeeded, lambda: dict_from_expr(sqrt(2), greedy=False))
assert dict_from_expr(x*y, domain=ZZ.poly_ring(x)) == ({(1,): x}, (y,))
assert dict_from_expr(x*y, domain=ZZ.poly_ring(y)) == ({(1,): y}, (x,))
assert dict_from_expr(3*sqrt(
2)*pi*x*y, extension=None) == ({(1, 1, 1, 1): 3}, (x, y, pi, sqrt(2)))
assert dict_from_expr(3*sqrt(
2)*pi*x*y, extension=True) == ({(1, 1, 1): 3*sqrt(2)}, (x, y, pi))
f = cos(x)*sin(x) + cos(x)*sin(y) + cos(y)*sin(x) + cos(y)*sin(y)
assert dict_from_expr(f) == ({(0, 1, 0, 1): 1, (0, 1, 1, 0): 1,
(1, 0, 0, 1): 1, (1, 0, 1, 0): 1}, (cos(x), cos(y), sin(x), sin(y)))
def test_sring():
x, y, z, t = symbols("x,y,z,t")
R = ZZ.poly_ring("x", "y", "z")
assert sring(x + 2*y + 3*z) == (R, R.x + 2*R.y + 3*R.z)
R = QQ.poly_ring("x", "y", "z")
assert sring(x + 2*y + z/3) == (R, R.x + 2*R.y + R.z/3)
assert sring([x, 2*y, z/3]) == (R, [R.x, 2*R.y, R.z/3])
Rt = ZZ.poly_ring("t")
R = Rt.poly_ring("x", "y", "z")
assert sring(x + 2*t*y + 3*t**2*z, x, y, z) == (R, R.x + 2*Rt.t*R.y + 3*Rt.t**2*R.z)
Rt = QQ.poly_ring("t")
R = Rt.poly_ring("x", "y", "z")
assert sring(x + t*y/2 + t**2*z/3, x, y, z) == (R, R.x + Rt.t*R.y/2 + Rt.t**2*R.z/3)
Rt = ZZ.frac_field("t")
R = Rt.poly_ring("x", "y", "z")
assert sring(x + 2*y/t + t**2*z/3, x, y, z) == (R, R.x + 2*R.y/Rt.t + Rt.t**2*R.z/3)
R = QQ.poly_ring("x", "y")
assert sring(x + y, domain=QQ) == (R, R.x + R.y)
def test_units():
R = QQ.poly_ring(x)
assert R.convert(1) == R.one
assert R.convert(x) != R.one
assert R.convert(1 + x) != R.one
R = QQ.poly_ring(x, order='ilex')
assert R.convert(1) == R.one
assert R.convert(x) != R.one
R = ZZ.poly_ring(x)
assert R.convert(1) == R.one
assert R.convert(2) != R.one
assert R.convert(x) != R.one
assert R.convert(1 + x) != R.one
def test_sring():
x, y, z, t = symbols("x,y,z,t")
R = ZZ.poly_ring("x", "y", "z")
assert sring(x + 2*y + 3*z) == (R, R.x + 2*R.y + 3*R.z)
R = QQ.poly_ring("x", "y", "z")
assert sring(x + 2*y + z/3) == (R, R.x + 2*R.y + R.z/3)
assert sring([x, 2*y, z/3]) == (R, [R.x, 2*R.y, R.z/3])
Rt = ZZ.poly_ring("t")
R = Rt.poly_ring("x", "y", "z")
assert sring(x + 2*t*y + 3*t**2*z, x, y, z) == (R, R.x + 2*Rt.t*R.y + 3*Rt.t**2*R.z)
Rt = QQ.poly_ring("t")
R = Rt.poly_ring("x", "y", "z")
assert sring(x + t*y/2 + t**2*z/3, x, y, z) == (R, R.x + Rt.t*R.y/2 + Rt.t**2*R.z/3)
Rt = ZZ.frac_field("t")
R = Rt.poly_ring("x", "y", "z")
assert sring(x + 2*y/t + t**2*z/3, x, y, z) == (R, R.x + 2*R.y/Rt.t + Rt.t**2*R.z/3)
R = QQ.poly_ring("x", "y")
assert sring(x + y, domain=QQ) == (R, R.x + R.y)
def test_PolynomialRing_drop():
R, x, y, z = ring("x,y,z", ZZ)
assert R.drop(x) == ZZ.poly_ring("y", "z")
assert R.drop(y) == ZZ.poly_ring("x", "z")
assert R.drop(z) == ZZ.poly_ring("x", "y")
assert R.drop(0) == ZZ.poly_ring("y", "z")
assert R.drop(0).drop(0) == ZZ.poly_ring("z")
assert R.drop(0).drop(0).drop(0) == ZZ
assert R.drop(1) == ZZ.poly_ring("x", "z")
assert R.drop(2) == ZZ.poly_ring("x", "y")
assert R.drop(2).drop(1) == ZZ.poly_ring("x")
assert R.drop(2).drop(1).drop(0) == ZZ
pytest.raises(ValueError, lambda: R.drop(3))
pytest.raises(ValueError, lambda: R.drop(x).drop(y))
def test_PolynomialRing_drop():
R, x, y, z = ring("x,y,z", ZZ)
assert R.drop(x) == ZZ.poly_ring("y", "z")
assert R.drop(y) == ZZ.poly_ring("x", "z")
assert R.drop(z) == ZZ.poly_ring("x", "y")
assert R.drop(0) == ZZ.poly_ring("y", "z")
assert R.drop(0).drop(0) == ZZ.poly_ring("z")
assert R.drop(0).drop(0).drop(0) == ZZ
assert R.drop(1) == ZZ.poly_ring("x", "z")
assert R.drop(2) == ZZ.poly_ring("x", "y")
assert R.drop(2).drop(1) == ZZ.poly_ring("x")
assert R.drop(2).drop(1).drop(0) == ZZ
pytest.raises(ValueError, lambda: R.drop(3))
pytest.raises(ValueError, lambda: R.drop(x).drop(y))
def test_dup_isolate_all_roots():
R, x = ring("x", ZZ)
f = 4*x**4 - x**3 + 2*x**2 + 5*x
assert R.dup_isolate_all_roots(f) == \
([((-1, 0), 1), ((0, 0), 1)],
[(((0, -QQ(5, 2)), (QQ(5, 2), 0)), 1),
(((0, 0), (QQ(5, 2), QQ(5, 2))), 1)])
assert R.dup_isolate_all_roots(f, eps=QQ(1, 10)) == \
([((QQ(-7, 8), QQ(-6, 7)), 1), ((0, 0), 1)],
[(((QQ(35, 64), -QQ(35, 32)), (QQ(5, 8), -QQ(65, 64))), 1),
(((QQ(35, 64), QQ(65, 64)), (QQ(5, 8), QQ(35, 32))), 1)])
f = x**5 + x**4 - 2*x**3 - 2*x**2 + x + 1
pytest.raises(NotImplementedError, lambda: R.dup_isolate_all_roots(f))
D = ZZ.poly_ring("y")
R, x = ring("x", D)
y, = D.gens
f = x**2 + y*x - 1
pytest.raises(DomainError, lambda: R.dup_isolate_all_roots(f))
def test_dup_isolate_all_roots():
R, x = ring("x", ZZ)
f = 4 * x**4 - x**3 + 2 * x**2 + 5 * x
assert R.dup_isolate_all_roots(f) == \
([((-1, 0), 1), ((0, 0), 1)],
[(((0, -QQ(5, 2)), (QQ(5, 2), 0)), 1),
(((0, 0), (QQ(5, 2), QQ(5, 2))), 1)])
assert R.dup_isolate_all_roots(f, eps=QQ(1, 10)) == \
([((QQ(-7, 8), QQ(-6, 7)), 1), ((0, 0), 1)],
[(((QQ(35, 64), -QQ(35, 32)), (QQ(5, 8), -QQ(65, 64))), 1),
(((QQ(35, 64), QQ(65, 64)), (QQ(5, 8), QQ(35, 32))), 1)])
f = x**5 + x**4 - 2 * x**3 - 2 * x**2 + x + 1
pytest.raises(NotImplementedError, lambda: R.dup_isolate_all_roots(f))
D = ZZ.poly_ring("y")
R, x = ring("x", D)
y, = D.gens
f = x**2 + y * x - 1
pytest.raises(DomainError, lambda: R.dup_isolate_all_roots(f))
def test_FractionField():
assert str(ZZ.frac_field("x")) == "ZZ(x)"
assert str(QQ.frac_field("x", "y", order=grlex)) == "QQ(x,y)"
assert str(ZZ.poly_ring("t").frac_field("x", "y", "z")) == "ZZ[t](x,y,z)"
def test_Domain_unify_with_symbols():
pytest.raises(UnificationFailed, lambda: ZZ.poly_ring(x, y).unify(ZZ, (y, z)))
pytest.raises(UnificationFailed, lambda: ZZ.unify(ZZ.poly_ring(x, y), (y, z)))
def test_Domain_unify_composite():
assert unify(ZZ.poly_ring(x), ZZ) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), QQ) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), ZZ) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), QQ) == QQ.poly_ring(x)
assert unify(ZZ, ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(QQ, ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(ZZ, QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ, QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(ZZ.poly_ring(x, y), ZZ) == ZZ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), ZZ) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
assert unify(ZZ, ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert unify(QQ, ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(ZZ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(QQ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), ZZ) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), QQ) == QQ.frac_field(x)
assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ, QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ, QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x, y), ZZ) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), ZZ) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
assert unify(ZZ, ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ, ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(QQ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x)) == ZZ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x), ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x,
z)) == ZZ.poly_ring(x, y, z)
assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x,
z)) == QQ.poly_ring(x, y, z)
assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x,
z)) == QQ.poly_ring(x, y, z)
assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x,
z)) == QQ.poly_ring(x, y, z)
assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), ZZ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x), ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y),
ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(ZZ.frac_field(x, y),
QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y),
ZZ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y),
QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(ZZ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.poly_ring(x), QQ.frac_field(x)) == ZZ.frac_field(x)
assert unify(QQ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(QQ.poly_ring(x), QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(ZZ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(ZZ.poly_ring(x), QQ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.poly_ring(x, y),
ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(ZZ.poly_ring(x, y),
QQ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.poly_ring(x, y),
ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.poly_ring(x, y),
QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(ZZ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(QQ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(QQ.frac_field(x), QQ.poly_ring(x)) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), QQ.poly_ring(x)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x), QQ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x), QQ.poly_ring(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y),
ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert unify(ZZ.frac_field(x, y),
QQ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y),
ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y),
QQ.poly_ring(x, z)) == QQ.frac_field(x, y, z)
def test_PolynomialRing():
assert str(ZZ.poly_ring("x")) == "ZZ[x]"
assert str(QQ.poly_ring("x", "y", order=grlex)) == "QQ[x,y]"
assert str(ZZ.poly_ring("t").poly_ring("x", "y", "z")) == "ZZ[t][x,y,z]"
def test_dup_refine_real_root():
R, x = ring("x", ZZ)
f = x**2 - 2
assert R.dup_refine_real_root(f, QQ(1), QQ(1), steps=1) == (1, 1)
assert R.dup_refine_real_root(f, QQ(1), QQ(1), steps=9) == (1, 1)
pytest.raises(ValueError, lambda: R.dup_refine_real_root(f, QQ(-2), QQ(2)))
s, t = QQ(1, 1), QQ(2, 1)
assert R.dup_refine_real_root(f, s, t, steps=0) == (1, 2)
assert R.dup_refine_real_root(f, s, t, steps=1) == (1, QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=2) == (QQ(4, 3), QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=3) == (QQ(7, 5), QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=4) == (QQ(7, 5), QQ(10, 7))
s, t = QQ(1, 1), QQ(3, 2)
assert R.dup_refine_real_root(f, s, t, steps=0) == (1, QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=1) == (QQ(4, 3), QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=2) == (QQ(7, 5), QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=3) == (QQ(7, 5), QQ(10, 7))
assert R.dup_refine_real_root(f, s, t, steps=4) == (QQ(7, 5), QQ(17, 12))
s, t = QQ(1, 1), QQ(5, 3)
assert R.dup_refine_real_root(f, s, t, steps=0) == (1, QQ(5, 3))
assert R.dup_refine_real_root(f, s, t, steps=1) == (1, QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=2) == (QQ(7, 5), QQ(3, 2))
assert R.dup_refine_real_root(f, s, t, steps=3) == (QQ(7, 5), QQ(13, 9))
assert R.dup_refine_real_root(f, s, t, steps=4) == (QQ(7, 5), QQ(27, 19))
s, t = QQ(-1, 1), QQ(-2, 1)
assert R.dup_refine_real_root(f, s, t, steps=0) == (-QQ(2, 1), -QQ(1, 1))
assert R.dup_refine_real_root(f, s, t, steps=1) == (-QQ(3, 2), -QQ(1, 1))
assert R.dup_refine_real_root(f, s, t, steps=2) == (-QQ(3, 2), -QQ(4, 3))
assert R.dup_refine_real_root(f, s, t, steps=3) == (-QQ(3, 2), -QQ(7, 5))
assert R.dup_refine_real_root(f, s, t, steps=4) == (-QQ(10, 7), -QQ(7, 5))
pytest.raises(RefinementFailed, lambda: R.dup_refine_real_root(f, QQ(0), QQ(1)))
s, t, u, v, w = QQ(1), QQ(2), QQ(24, 17), QQ(17, 12), QQ(7, 5)
assert R.dup_refine_real_root(f, s, t, eps=QQ(1, 100)) == (u, v)
assert R.dup_refine_real_root(f, s, t, steps=6) == (u, v)
assert R.dup_refine_real_root(f, s, t, eps=QQ(1, 100), steps=5) == (w, v)
assert R.dup_refine_real_root(f, s, t, eps=QQ(1, 100), steps=6) == (u, v)
assert R.dup_refine_real_root(f, s, t, eps=QQ(1, 100), steps=7) == (u, v)
s, t, u, v = QQ(-2), QQ(-1), QQ(-3, 2), QQ(-4, 3)
assert R.dup_refine_real_root(f, s, t, disjoint=QQ(-5)) == (s, t)
assert R.dup_refine_real_root(f, s, t, disjoint=-v) == (s, t)
assert R.dup_refine_real_root(f, s, t, disjoint=v) == (u, v)
s, t, u, v = QQ(1), QQ(2), QQ(4, 3), QQ(3, 2)
assert R.dup_refine_real_root(f, s, t, disjoint=QQ(5)) == (s, t)
assert R.dup_refine_real_root(f, s, t, disjoint=-u) == (s, t)
assert R.dup_refine_real_root(f, s, t, disjoint=u) == (u, v)
R, x = ring("x", QQ)
f = x**2 - QQ(1, 4)
assert R.dup_refine_real_root(f, QQ(0), QQ(1),
steps=1) == (QQ(1, 2), QQ(1, 2))
D = ZZ.poly_ring("y")
y, = D.gens
R, x = ring("x", D)
f = x**2 + y*x - 1
pytest.raises(DomainError, lambda: R.dup_refine_real_root(f, ZZ(0), ZZ(1)))
def test_construct_domain():
assert construct_domain([1, 2, 3]) == (ZZ, [ZZ(1), ZZ(2), ZZ(3)])
assert construct_domain([1, 2, 3],
field=True) == (QQ, [QQ(1), QQ(2),
QQ(3)])
assert construct_domain([Integer(1), Integer(2),
Integer(3)]) == (ZZ, [ZZ(1), ZZ(2),
ZZ(3)])
assert construct_domain(
[Integer(1), Integer(2), Integer(3)],
field=True) == (QQ, [QQ(1), QQ(2), QQ(3)])
assert construct_domain([Rational(1, 2),
Integer(2)]) == (QQ, [QQ(1, 2), QQ(2)])
assert construct_domain([3.14, 1, Rational(1, 2)
]) == (RR, [RR(3.14), RR(1.0),
RR(0.5)])
assert construct_domain([3.14, sqrt(2)],
extension=None) == (EX, [EX(3.14),
EX(sqrt(2))])
assert construct_domain([3.14, sqrt(2)],
extension=True) == (EX, [EX(3.14),
EX(sqrt(2))])
assert construct_domain([sqrt(2), 3.14],
extension=True) == (EX, [EX(sqrt(2)),
EX(3.14)])
assert construct_domain([1, sqrt(2)],
extension=None) == (EX, [EX(1), EX(sqrt(2))])
assert construct_domain([x, sqrt(x)]) == (EX, [EX(x), EX(sqrt(x))])
assert construct_domain([x, sqrt(x), sqrt(y)
]) == (EX, [EX(x),
EX(sqrt(x)),
EX(sqrt(y))])
alg = QQ.algebraic_field(sqrt(2))
assert (construct_domain(
[7, Rational(1, 2), sqrt(2)],
extension=True) == (alg, [alg(7),
alg(Rational(1, 2)),
alg(sqrt(2))]))
alg = QQ.algebraic_field(sqrt(2) + sqrt(3))
assert (construct_domain([7, sqrt(2), sqrt(3)], extension=True) == (alg, [
alg(7), alg(sqrt(2)), alg(sqrt(3))
]))
dom = ZZ.poly_ring(x)
assert construct_domain([2 * x, 3]) == (dom, [dom(2 * x), dom(3)])
dom = ZZ.poly_ring(x, y)
assert construct_domain([2 * x, 3 * y]) == (dom, [dom(2 * x), dom(3 * y)])
dom = QQ.poly_ring(x)
assert construct_domain([x / 2, 3]) == (dom, [dom(x / 2), dom(3)])
dom = QQ.poly_ring(x, y)
assert construct_domain([x / 2, 3 * y]) == (dom, [dom(x / 2), dom(3 * y)])
dom = RR.poly_ring(x)
assert construct_domain([x / 2, 3.5]) == (dom, [dom(x / 2), dom(3.5)])
dom = RR.poly_ring(x, y)
assert construct_domain([x / 2,
3.5 * y]) == (dom, [dom(x / 2),
dom(3.5 * y)])
dom = ZZ.frac_field(x)
assert construct_domain([2 / x, 3]) == (dom, [dom(2 / x), dom(3)])
dom = ZZ.frac_field(x, y)
assert construct_domain([2 / x, 3 * y]) == (dom, [dom(2 / x), dom(3 * y)])
dom = RR.frac_field(x)
assert construct_domain([2 / x, 3.5]) == (dom, [dom(2 / x), dom(3.5)])
dom = RR.frac_field(x, y)
assert construct_domain([2 / x,
3.5 * y]) == (dom, [dom(2 / x),
dom(3.5 * y)])
assert construct_domain(2) == (ZZ, ZZ(2))
assert construct_domain(Rational(2, 3)) == (QQ, QQ(2, 3))
assert construct_domain({}) == (ZZ, {})
def test_Domain_unify():
F3 = GF(3)
assert unify(F3, F3) == F3
assert unify(F3, ZZ) == F3
assert unify(F3, QQ) == QQ
assert unify(F3, ALG) == ALG
assert unify(F3, RR) == RR
assert unify(F3, CC) == CC
assert unify(F3, ZZ.poly_ring(x)) == F3.poly_ring(x)
assert unify(F3, ZZ.frac_field(x)) == F3.frac_field(x)
assert unify(F3, EX) == EX
assert unify(ZZ, F3) == F3
assert unify(ZZ, ZZ) == ZZ
assert unify(ZZ, QQ) == QQ
assert unify(ZZ, ALG) == ALG
assert unify(ZZ, RR) == RR
assert unify(ZZ, CC) == CC
assert unify(ZZ, ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ, EX) == EX
assert unify(QQ, F3) == QQ
assert unify(QQ, ZZ) == QQ
assert unify(QQ, QQ) == QQ
assert unify(QQ, ALG) == ALG
assert unify(QQ, RR) == RR
assert unify(QQ, CC) == CC
assert unify(QQ, ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ, EX) == EX
assert unify(RR, F3) == RR
assert unify(RR, ZZ) == RR
assert unify(RR, QQ) == RR
assert unify(RR, ALG) == RR
assert unify(RR, RR) == RR
assert unify(RR, CC) == CC
assert unify(RR, ZZ.poly_ring(x)) == RR.poly_ring(x)
assert unify(RR, ZZ.frac_field(x)) == RR.frac_field(x)
assert unify(RR, EX) == EX
assert unify(CC, F3) == CC
assert unify(CC, ZZ) == CC
assert unify(CC, QQ) == CC
assert unify(CC, ALG) == CC
assert unify(CC, RR) == CC
assert unify(CC, CC) == CC
assert unify(CC, ZZ.poly_ring(x)) == CC.poly_ring(x)
assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
assert unify(CC, EX) == EX
CC2 = ComplexField(prec=20)
assert unify(CC, CC2) == unify(CC2, CC) == ComplexField(prec=CC.precision,
tol=CC2.tolerance)
RR2 = RealField(prec=20)
assert unify(RR, RR2) == unify(RR2, RR) == RealField(prec=RR.precision,
tol=RR2.tolerance)
assert unify(ZZ.poly_ring(x), F3) == F3.poly_ring(x)
assert unify(ZZ.poly_ring(x), ZZ) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), QQ) == QQ.poly_ring(x)
assert unify(ZZ.poly_ring(x), ALG) == ALG.poly_ring(x)
assert unify(ZZ.poly_ring(x), RR) == RR.poly_ring(x)
assert unify(ZZ.poly_ring(x), CC) == CC.poly_ring(x)
assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.poly_ring(x), EX) == EX
assert unify(ZZ.frac_field(x), F3) == F3.frac_field(x)
assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x), ALG) == ALG.frac_field(x)
assert unify(ZZ.frac_field(x), RR) == RR.frac_field(x)
assert unify(ZZ.frac_field(x), CC) == CC.frac_field(x)
assert unify(ZZ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), EX) == EX
assert unify(EX, F3) == EX
assert unify(EX, ZZ) == EX
assert unify(EX, QQ) == EX
assert unify(EX, ALG) == EX
assert unify(EX, RR) == EX
assert unify(EX, CC) == EX
assert unify(EX, ZZ.poly_ring(x)) == EX
assert unify(EX, ZZ.frac_field(x)) == EX
assert unify(EX, EX) == EX
def test_FractionField():
assert str(ZZ.frac_field("x")) == "ZZ(x)"
assert str(QQ.frac_field("x", "y", order=grlex)) == "QQ(x,y)"
assert str(ZZ.poly_ring("t").frac_field("x", "y", "z")) == "ZZ[t](x,y,z)"
def test_inject():
assert ZZ.inject(x, y, z) == ZZ.poly_ring(x, y, z)
assert ZZ.poly_ring(x).inject(y, z) == ZZ.poly_ring(x, y, z)
assert ZZ.frac_field(x).inject(y, z) == ZZ.frac_field(x, y, z)
pytest.raises(GeneratorsError, lambda: ZZ.poly_ring(x).inject(x))
def test_PolynomialRing__init():
pytest.raises(GeneratorsNeeded, lambda: ZZ.poly_ring())
def test_dmp_factor_list():
R, x = ring("x", ZZ)
assert R.dmp_factor_list(0) == (0, [])
assert R.dmp_factor_list(7) == (7, [])
R, x = ring("x", QQ)
assert R.dmp_factor_list(0) == (0, [])
assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
R, x = ring("x", ZZ.poly_ring('t'))
assert R.dmp_factor_list(0) == (0, [])
assert R.dmp_factor_list(7) == (7, [])
R, x = ring("x", QQ.poly_ring('t'))
assert R.dmp_factor_list(0) == (0, [])
assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
R, x = ring("x", ZZ)
assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)])
# issue sympy/sympy#8037
assert R.dmp_factor_list(6*x**2 - 5*x - 6) == (1, [(2*x - 3, 1), (3*x + 2, 1)])
R, x = ring("x", QQ)
assert R.dmp_factor_list(x**2/2 + x + QQ(1, 2)) == (QQ(1, 2), [(x + 1, 2)])
R, x = ring("x", FF(2))
assert R.dmp_factor_list(x**2 + 1) == (1, [(x + 1, 2)])
R, x = ring("x", RR)
assert R.dmp_factor_list(1.0*x**2 + 2.0*x + 1.0) == (1.0, [(1.0*x + 1.0, 2)])
assert R.dmp_factor_list(2.0*x**2 + 4.0*x + 2.0) == (2.0, [(1.0*x + 1.0, 2)])
f = 6.7225336055071*x**2 - 10.6463972754741*x - 0.33469524022264
coeff, factors = R.dmp_factor_list(f)
assert coeff == RR(1.0) and len(factors) == 1 and factors[0][0].almosteq(f, 1e-10) and factors[0][1] == 1
# issue diofant/diofant#238
f = 0.1*x**2 + 1.1*x + 1.0
assert R.dmp_factor_list(f) == (10.0, [(0.1*x + 0.1, 1), (0.1*x + 1.0, 1)])
f = 0.25 + 1.0*x + 1.0*x**2
assert R.dmp_factor_list(f) == (4.0, [(0.25 + 0.5*x, 2)])
Rt, t = ring("t", ZZ)
R, x = ring("x", Rt)
f = 4*t*x**2 + 4*t**2*x
assert R.dmp_factor_list(f) == (4*t, [(x, 1), (x + t, 1)])
Rt, t = ring("t", QQ)
R, x = ring("x", Rt)
f = t*x**2/2 + t**2*x/2
assert R.dmp_factor_list(f) == (t/2, [(x, 1), (x + t, 1)])
R, x = ring("x", QQ.algebraic_field(I))
f = x**4 + 2*x**2
assert R.dmp_factor_list(f) == (R.domain(1), [(x, 2), (x**2 + 2, 1)])
R, x = ring("x", EX)
pytest.raises(DomainError, lambda: R.dmp_factor_list(EX(sin(1))))
R, x, y = ring("x,y", ZZ)
assert R.dmp_factor_list(0) == (ZZ(0), [])
assert R.dmp_factor_list(7) == (7, [])
R, x, y = ring("x,y", QQ)
assert R.dmp_factor_list(0) == (QQ(0), [])
assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
Rt, t = ring("t", ZZ)
R, x, y = ring("x,y", Rt)
assert R.dmp_factor_list(0) == (0, [])
assert R.dmp_factor_list(7) == (ZZ(7), [])
Rt, t = ring("t", QQ)
R, x, y = ring("x,y", Rt)
assert R.dmp_factor_list(0) == (0, [])
assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), [])
R, *X = ring("x:200", ZZ)
f, g = X[0]**2 + 2*X[0] + 1, X[0] + 1
assert R.dmp_factor_list(f) == (1, [(g, 2)])
f, g = X[-1]**2 + 2*X[-1] + 1, X[-1] + 1
assert R.dmp_factor_list(f) == (1, [(g, 2)])
R, x = ring("x", ZZ)
assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)])
R, x = ring("x", QQ)
assert R.dmp_factor_list(x**2/2 + x + QQ(1, 2)) == (QQ(1, 2), [(x + 1, 2)])
R, x, y = ring("x,y", ZZ)
assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)])
R, x, y = ring("x,y", QQ)
assert R.dmp_factor_list(x**2/2 + x + QQ(1, 2)) == (QQ(1, 2), [(x + 1, 2)])
R, x, y = ring("x,y", ZZ)
f = 4*x**2*y + 4*x*y**2
assert R.dmp_factor_list(f) == (4, [(y, 1), (x, 1), (x + y, 1)])
R, x, y = ring("x,y", QQ)
f = x**2*y/2 + x*y**2/2
assert R.dmp_factor_list(f) == (QQ(1, 2), [(y, 1), (x, 1), (x + y, 1)])
R, x, y = ring("x,y", RR)
f = 2.0*x**2 - 8.0*y**2
assert R.dmp_factor_list(f) == (RR(2.0), [(1.0*x - 2.0*y, 1), (1.0*x + 2.0*y, 1)])
f = 6.7225336055071*x**2*y**2 - 10.6463972754741*x*y - 0.33469524022264
coeff, factors = R.dmp_factor_list(f)
assert coeff == RR(1.0) and len(factors) == 1 and factors[0][0].almosteq(f, 1e-10) and factors[0][1] == 1
# issue diofant/diofant#238
R, x, y, z = ring("x,y,z", RR)
f = x*y + x*z + 0.1*y + 0.1*z
assert R.dmp_factor_list(f) == (10.0, [(0.1*y + 0.1*z, 1), (x + 0.1, 1)])
f = 0.25*x**2 + 1.0*x*y*z + 1.0*y**2*z**2
assert R.dmp_factor_list(f) == (4.0, [(0.25*x + 0.5*y*z, 2)])
Rt, t = ring("t", ZZ)
R, x, y = ring("x,y", Rt)
f = 4*t*x**2 + 4*t**2*x
assert R.dmp_factor_list(f) == (4*t, [(x, 1), (x + t, 1)])
Rt, t = ring("t", QQ)
R, x, y = ring("x,y", Rt)
f = t*x**2/2 + t**2*x/2
assert R.dmp_factor_list(f) == (t/2, [(x, 1), (x + t, 1)])
R, x, y = ring("x,y", FF(2))
pytest.raises(NotImplementedError, lambda: R.dmp_factor_list(x**2 + y**2))
R, x, y = ring("x,y", EX)
pytest.raises(DomainError, lambda: R.dmp_factor_list(EX(sin(1))))
def test_Domain__contains__():
assert (0 in EX) is True
assert (0 in ZZ) is True
assert (0 in QQ) is True
assert (0 in RR) is True
assert (0 in CC) is True
assert (0 in ALG) is True
assert (0 in ZZ.poly_ring(x, y)) is True
assert (0 in QQ.poly_ring(x, y)) is True
assert (0 in RR.poly_ring(x, y)) is True
assert (-7 in EX) is True
assert (-7 in ZZ) is True
assert (-7 in QQ) is True
assert (-7 in RR) is True
assert (-7 in CC) is True
assert (-7 in ALG) is True
assert (-7 in ZZ.poly_ring(x, y)) is True
assert (-7 in QQ.poly_ring(x, y)) is True
assert (-7 in RR.poly_ring(x, y)) is True
assert (17 in EX) is True
assert (17 in ZZ) is True
assert (17 in QQ) is True
assert (17 in RR) is True
assert (17 in CC) is True
assert (17 in ALG) is True
assert (17 in ZZ.poly_ring(x, y)) is True
assert (17 in QQ.poly_ring(x, y)) is True
assert (17 in RR.poly_ring(x, y)) is True
assert (-Rational(1, 7) in EX) is True
assert (-Rational(1, 7) in ZZ) is False
assert (-Rational(1, 7) in QQ) is True
assert (-Rational(1, 7) in RR) is True
assert (-Rational(1, 7) in CC) is True
assert (-Rational(1, 7) in ALG) is True
assert (-Rational(1, 7) in ZZ.poly_ring(x, y)) is False
assert (-Rational(1, 7) in QQ.poly_ring(x, y)) is True
assert (-Rational(1, 7) in RR.poly_ring(x, y)) is True
assert (Rational(3, 5) in EX) is True
assert (Rational(3, 5) in ZZ) is False
assert (Rational(3, 5) in QQ) is True
assert (Rational(3, 5) in RR) is True
assert (Rational(3, 5) in CC) is True
assert (Rational(3, 5) in ALG) is True
assert (Rational(3, 5) in ZZ.poly_ring(x, y)) is False
assert (Rational(3, 5) in QQ.poly_ring(x, y)) is True
assert (Rational(3, 5) in RR.poly_ring(x, y)) is True
assert (3.0 in EX) is True
assert (3.0 in ZZ) is True
assert (3.0 in QQ) is True
assert (3.0 in RR) is True
assert (3.0 in CC) is True
assert (3.0 in ALG) is True
assert (3.0 in ZZ.poly_ring(x, y)) is True
assert (3.0 in QQ.poly_ring(x, y)) is True
assert (3.0 in RR.poly_ring(x, y)) is True
assert (3.14 in EX) is True
assert (3.14 in ZZ) is False
assert (3.14 in QQ) is True
assert (3.14 in RR) is True
assert (3.14 in CC) is True
assert (3.14 in ALG) is True
assert (3.14 in ZZ.poly_ring(x, y)) is False
assert (3.14 in QQ.poly_ring(x, y)) is True
assert (3.14 in RR.poly_ring(x, y)) is True
assert (oo in EX) is True
assert (oo in ZZ) is False
assert (oo in QQ) is False
assert (oo in RR) is True
assert (oo in CC) is True
assert (oo in ALG) is False
assert (oo in ZZ.poly_ring(x, y)) is False
assert (oo in QQ.poly_ring(x, y)) is False
assert (oo in RR.poly_ring(x, y)) is True
assert (-oo in EX) is True
assert (-oo in ZZ) is False
assert (-oo in QQ) is False
assert (-oo in RR) is True
assert (-oo in CC) is True
assert (-oo in ALG) is False
assert (-oo in ZZ.poly_ring(x, y)) is False
assert (-oo in QQ.poly_ring(x, y)) is False
assert (-oo in RR.poly_ring(x, y)) is True
assert (sqrt(7) in EX) is True
assert (sqrt(7) in ZZ) is False
assert (sqrt(7) in QQ) is False
assert (sqrt(7) in RR) is True
assert (sqrt(7) in CC) is True
assert (sqrt(7) in ALG) is False
assert (sqrt(7) in ZZ.poly_ring(x, y)) is False
assert (sqrt(7) in QQ.poly_ring(x, y)) is False
assert (sqrt(7) in RR.poly_ring(x, y)) is True
assert (2 * sqrt(3) + 1 in EX) is True
assert (2 * sqrt(3) + 1 in ZZ) is False
assert (2 * sqrt(3) + 1 in QQ) is False
assert (2 * sqrt(3) + 1 in RR) is True
assert (2 * sqrt(3) + 1 in CC) is True
assert (2 * sqrt(3) + 1 in ALG) is True
assert (2 * sqrt(3) + 1 in ZZ.poly_ring(x, y)) is False
assert (2 * sqrt(3) + 1 in QQ.poly_ring(x, y)) is False
assert (2 * sqrt(3) + 1 in RR.poly_ring(x, y)) is True
assert (sin(1) in EX) is True
assert (sin(1) in ZZ) is False
assert (sin(1) in QQ) is False
assert (sin(1) in RR) is True
assert (sin(1) in CC) is True
assert (sin(1) in ALG) is False
assert (sin(1) in ZZ.poly_ring(x, y)) is False
assert (sin(1) in QQ.poly_ring(x, y)) is False
assert (sin(1) in RR.poly_ring(x, y)) is True
assert (x**2 + 1 in EX) is True
assert (x**2 + 1 in ZZ) is False
assert (x**2 + 1 in QQ) is False
assert (x**2 + 1 in RR) is False
assert (x**2 + 1 in CC) is False
assert (x**2 + 1 in ALG) is False
assert (x**2 + 1 in ZZ.poly_ring(x)) is True
assert (x**2 + 1 in QQ.poly_ring(x)) is True
assert (x**2 + 1 in RR.poly_ring(x)) is True
assert (x**2 + 1 in ZZ.poly_ring(x, y)) is True
assert (x**2 + 1 in QQ.poly_ring(x, y)) is True
assert (x**2 + 1 in RR.poly_ring(x, y)) is True
assert (x**2 + y**2 in EX) is True
assert (x**2 + y**2 in ZZ) is False
assert (x**2 + y**2 in QQ) is False
assert (x**2 + y**2 in RR) is False
assert (x**2 + y**2 in CC) is False
assert (x**2 + y**2 in ALG) is False
assert (x**2 + y**2 in ZZ.poly_ring(x)) is False
assert (x**2 + y**2 in QQ.poly_ring(x)) is False
assert (x**2 + y**2 in RR.poly_ring(x)) is False
assert (x**2 + y**2 in ZZ.poly_ring(x, y)) is True
assert (x**2 + y**2 in QQ.poly_ring(x, y)) is True
assert (x**2 + y**2 in RR.poly_ring(x, y)) is True
assert (Rational(3, 2) * x / (y + 1) - z in QQ.poly_ring(x, y, z)) is False
def test_Domain_unify_with_symbols():
pytest.raises(UnificationFailed,
lambda: ZZ.poly_ring(x, y).unify(ZZ, (y, z)))
pytest.raises(UnificationFailed, lambda: ZZ.unify(ZZ.poly_ring(x, y),
(y, z)))
def test_Domain_unify_composite():
assert unify(ZZ.poly_ring(x), ZZ) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), QQ) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), ZZ) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), QQ) == QQ.poly_ring(x)
assert unify(ZZ, ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(QQ, ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(ZZ, QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ, QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(ZZ.poly_ring(x, y), ZZ) == ZZ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), ZZ) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), QQ) == QQ.poly_ring(x, y)
assert unify(ZZ, ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert unify(QQ, ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(ZZ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(QQ, QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), ZZ) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), QQ) == QQ.frac_field(x)
assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ, QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ, QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x, y), ZZ) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), ZZ) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), QQ) == QQ.frac_field(x, y)
assert unify(ZZ, ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ, ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(QQ, QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ.poly_ring(x), QQ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x)) == ZZ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x), ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(QQ.poly_ring(x), QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert unify(ZZ.poly_ring(x, y), ZZ.poly_ring(x, z)) == ZZ.poly_ring(x, y, z)
assert unify(ZZ.poly_ring(x, y), QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
assert unify(QQ.poly_ring(x, y), ZZ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
assert unify(QQ.poly_ring(x, y), QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ.frac_field(x), QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), ZZ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x), ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(QQ.frac_field(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(ZZ.frac_field(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y), ZZ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(ZZ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.poly_ring(x), QQ.frac_field(x)) == ZZ.frac_field(x)
assert unify(QQ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(QQ.poly_ring(x), QQ.frac_field(x)) == QQ.frac_field(x)
assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x, y), QQ.frac_field(x)) == QQ.frac_field(x, y)
assert unify(ZZ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(ZZ.poly_ring(x), QQ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x), ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.poly_ring(x), QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.poly_ring(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(ZZ.poly_ring(x, y), QQ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.poly_ring(x, y), ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.poly_ring(x, y), QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert unify(ZZ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(QQ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(QQ.frac_field(x), QQ.poly_ring(x)) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x, y), QQ.poly_ring(x)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert unify(ZZ.frac_field(x), QQ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x), ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert unify(QQ.frac_field(x), QQ.poly_ring(x, y)) == QQ.frac_field(x, y)
assert unify(ZZ.frac_field(x, y), ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert unify(ZZ.frac_field(x, y), QQ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y), ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert unify(QQ.frac_field(x, y), QQ.poly_ring(x, z)) == QQ.frac_field(x, y, z)
def test_PolynomialRing__init():
pytest.raises(GeneratorsNeeded, lambda: ZZ.poly_ring())
def test_Domain_preprocess():
assert Domain.preprocess(ZZ) == ZZ
assert Domain.preprocess(QQ) == QQ
assert Domain.preprocess(EX) == EX
assert Domain.preprocess(FF(2)) == FF(2)
assert Domain.preprocess(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert Domain.preprocess('Z') == ZZ
assert Domain.preprocess('Q') == QQ
assert Domain.preprocess('ZZ') == ZZ
assert Domain.preprocess('QQ') == QQ
assert Domain.preprocess('EX') == EX
assert Domain.preprocess('FF(23)') == FF(23)
assert Domain.preprocess('GF(23)') == GF(23)
pytest.raises(OptionError, lambda: Domain.preprocess('Z[]'))
assert Domain.preprocess('Z[x]') == ZZ.poly_ring(x)
assert Domain.preprocess('Q[x]') == QQ.poly_ring(x)
assert Domain.preprocess('ZZ[x]') == ZZ.poly_ring(x)
assert Domain.preprocess('QQ[x]') == QQ.poly_ring(x)
assert Domain.preprocess('Z[x,y]') == ZZ.poly_ring(x, y)
assert Domain.preprocess('Q[x,y]') == QQ.poly_ring(x, y)
assert Domain.preprocess('ZZ[x,y]') == ZZ.poly_ring(x, y)
assert Domain.preprocess('QQ[x,y]') == QQ.poly_ring(x, y)
pytest.raises(OptionError, lambda: Domain.preprocess('Z()'))
assert Domain.preprocess('Z(x)') == ZZ.frac_field(x)
assert Domain.preprocess('Q(x)') == QQ.frac_field(x)
assert Domain.preprocess('ZZ(x)') == ZZ.frac_field(x)
assert Domain.preprocess('QQ(x)') == QQ.frac_field(x)
assert Domain.preprocess('Z(x,y)') == ZZ.frac_field(x, y)
assert Domain.preprocess('Q(x,y)') == QQ.frac_field(x, y)
assert Domain.preprocess('ZZ(x,y)') == ZZ.frac_field(x, y)
assert Domain.preprocess('QQ(x,y)') == QQ.frac_field(x, y)
assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I)
assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I)
assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
assert Domain.preprocess(
'QQ<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)
pytest.raises(OptionError, lambda: Domain.preprocess('abc'))
assert Domain.preprocess('RR') == RR
assert Domain.preprocess('RR_5') == RealField(prec=5)
assert Domain.preprocess('CC') == CC
assert Domain.preprocess('CC_5') == ComplexField(prec=5)
pytest.raises(OptionError, lambda: Domain.preprocess(()))
def test_inject():
assert ZZ.inject(x, y, z) == ZZ.poly_ring(x, y, z)
assert ZZ.poly_ring(x).inject(y, z) == ZZ.poly_ring(x, y, z)
assert ZZ.frac_field(x).inject(y, z) == ZZ.frac_field(x, y, z)
pytest.raises(GeneratorsError, lambda: ZZ.poly_ring(x).inject(x))
def test_PolynomialRing():
assert str(ZZ.poly_ring("x")) == "ZZ[x]"
assert str(QQ.poly_ring("x", "y", order=grlex)) == "QQ[x,y]"
assert str(ZZ.poly_ring("t").poly_ring("x", "y", "z")) == "ZZ[t][x,y,z]"
def test_Domain_unify():
F3 = GF(3)
assert unify(F3, F3) == F3
assert unify(F3, ZZ) == F3
assert unify(F3, QQ) == QQ
assert unify(F3, ALG) == ALG
assert unify(F3, RR) == RR
assert unify(F3, CC) == CC
assert unify(F3, ZZ.poly_ring(x)) == F3.poly_ring(x)
assert unify(F3, ZZ.frac_field(x)) == F3.frac_field(x)
assert unify(F3, EX) == EX
assert unify(ZZ, F3) == F3
assert unify(ZZ, ZZ) == ZZ
assert unify(ZZ, QQ) == QQ
assert unify(ZZ, ALG) == ALG
assert unify(ZZ, RR) == RR
assert unify(ZZ, CC) == CC
assert unify(ZZ, ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(ZZ, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ, EX) == EX
assert unify(QQ, F3) == QQ
assert unify(QQ, ZZ) == QQ
assert unify(QQ, QQ) == QQ
assert unify(QQ, ALG) == ALG
assert unify(QQ, RR) == RR
assert unify(QQ, CC) == CC
assert unify(QQ, ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ, EX) == EX
assert unify(RR, F3) == RR
assert unify(RR, ZZ) == RR
assert unify(RR, QQ) == RR
assert unify(RR, ALG) == RR
assert unify(RR, RR) == RR
assert unify(RR, CC) == CC
assert unify(RR, ZZ.poly_ring(x)) == RR.poly_ring(x)
assert unify(RR, ZZ.frac_field(x)) == RR.frac_field(x)
assert unify(RR, EX) == EX
assert unify(CC, F3) == CC
assert unify(CC, ZZ) == CC
assert unify(CC, QQ) == CC
assert unify(CC, ALG) == CC
assert unify(CC, RR) == CC
assert unify(CC, CC) == CC
assert unify(CC, ZZ.poly_ring(x)) == CC.poly_ring(x)
assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
assert unify(CC, EX) == EX
CC2 = ComplexField(prec=20)
assert unify(CC, CC2) == unify(CC2, CC) == ComplexField(prec=CC.precision,
tol=CC2.tolerance)
RR2 = RealField(prec=20)
assert unify(RR, RR2) == unify(RR2, RR) == RealField(prec=RR.precision,
tol=RR2.tolerance)
assert unify(ZZ.poly_ring(x), F3) == F3.poly_ring(x)
assert unify(ZZ.poly_ring(x), ZZ) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), QQ) == QQ.poly_ring(x)
assert unify(ZZ.poly_ring(x), ALG) == ALG.poly_ring(x)
assert unify(ZZ.poly_ring(x), RR) == RR.poly_ring(x)
assert unify(ZZ.poly_ring(x), CC) == CC.poly_ring(x)
assert unify(ZZ.poly_ring(x), ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert unify(ZZ.poly_ring(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.poly_ring(x), EX) == EX
assert unify(ZZ.frac_field(x), F3) == F3.frac_field(x)
assert unify(ZZ.frac_field(x), ZZ) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), QQ) == QQ.frac_field(x)
assert unify(ZZ.frac_field(x), ALG) == ALG.frac_field(x)
assert unify(ZZ.frac_field(x), RR) == RR.frac_field(x)
assert unify(ZZ.frac_field(x), CC) == CC.frac_field(x)
assert unify(ZZ.frac_field(x), ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ.frac_field(x), EX) == EX
assert unify(EX, F3) == EX
assert unify(EX, ZZ) == EX
assert unify(EX, QQ) == EX
assert unify(EX, ALG) == EX
assert unify(EX, RR) == EX
assert unify(EX, CC) == EX
assert unify(EX, ZZ.poly_ring(x)) == EX
assert unify(EX, ZZ.frac_field(x)) == EX
assert unify(EX, EX) == EX
def test_PolynomialRing___init__():
assert len(PolynomialRing(ZZ, "x,y,z").gens) == 3
assert len(ZZ.poly_ring(x).gens) == 1
assert len(ZZ.poly_ring("x", "y", "z").gens) == 3
assert len(ZZ.poly_ring(x, y, z).gens) == 3
pytest.raises(GeneratorsNeeded, lambda: ZZ.poly_ring())
pytest.raises(GeneratorsError, lambda: ZZ.poly_ring(0))
assert ZZ.poly_ring(t).poly_ring("x").domain == ZZ.poly_ring(t)
assert PolynomialRing('ZZ[t]', "x").domain == ZZ.poly_ring(t)
pytest.raises(GeneratorsError, lambda: ZZ.poly_ring("x").poly_ring("x"))
_lex = Symbol("lex")
assert PolynomialRing(ZZ, "x").order == lex
assert PolynomialRing(ZZ, "x", _lex).order == lex
assert PolynomialRing(ZZ, "x", 'lex').order == lex
R1 = ZZ.poly_ring("x", "y")
R2 = ZZ.poly_ring("x", "y")
R3 = ZZ.poly_ring("x", "y", "z")
assert R1.x == R1.gens[0]
assert R1.y == R1.gens[1]
assert R1.x == R2.x
assert R1.y == R2.y
assert R1.x != R3.x
assert R1.y != R3.y
R4 = ZZ.poly_ring("gens")
assert type(R4.gens) is tuple
pytest.raises(GeneratorsError, lambda: PolynomialRing(ZZ, {1: 2}))
pytest.raises(GeneratorsError, lambda: PolynomialRing(ZZ, ["x", ["y"]]))
def test_Domain__contains__():
assert (0 in EX) is True
assert (0 in ZZ) is True
assert (0 in QQ) is True
assert (0 in RR) is True
assert (0 in CC) is True
assert (0 in ALG) is True
assert (0 in ZZ.poly_ring(x, y)) is True
assert (0 in QQ.poly_ring(x, y)) is True
assert (0 in RR.poly_ring(x, y)) is True
assert (-7 in EX) is True
assert (-7 in ZZ) is True
assert (-7 in QQ) is True
assert (-7 in RR) is True
assert (-7 in CC) is True
assert (-7 in ALG) is True
assert (-7 in ZZ.poly_ring(x, y)) is True
assert (-7 in QQ.poly_ring(x, y)) is True
assert (-7 in RR.poly_ring(x, y)) is True
assert (17 in EX) is True
assert (17 in ZZ) is True
assert (17 in QQ) is True
assert (17 in RR) is True
assert (17 in CC) is True
assert (17 in ALG) is True
assert (17 in ZZ.poly_ring(x, y)) is True
assert (17 in QQ.poly_ring(x, y)) is True
assert (17 in RR.poly_ring(x, y)) is True
assert (-Rational(1, 7) in EX) is True
assert (-Rational(1, 7) in ZZ) is False
assert (-Rational(1, 7) in QQ) is True
assert (-Rational(1, 7) in RR) is True
assert (-Rational(1, 7) in CC) is True
assert (-Rational(1, 7) in ALG) is True
assert (-Rational(1, 7) in ZZ.poly_ring(x, y)) is False
assert (-Rational(1, 7) in QQ.poly_ring(x, y)) is True
assert (-Rational(1, 7) in RR.poly_ring(x, y)) is True
assert (Rational(3, 5) in EX) is True
assert (Rational(3, 5) in ZZ) is False
assert (Rational(3, 5) in QQ) is True
assert (Rational(3, 5) in RR) is True
assert (Rational(3, 5) in CC) is True
assert (Rational(3, 5) in ALG) is True
assert (Rational(3, 5) in ZZ.poly_ring(x, y)) is False
assert (Rational(3, 5) in QQ.poly_ring(x, y)) is True
assert (Rational(3, 5) in RR.poly_ring(x, y)) is True
assert (3.0 in EX) is True
assert (3.0 in ZZ) is True
assert (3.0 in QQ) is True
assert (3.0 in RR) is True
assert (3.0 in CC) is True
assert (3.0 in ALG) is True
assert (3.0 in ZZ.poly_ring(x, y)) is True
assert (3.0 in QQ.poly_ring(x, y)) is True
assert (3.0 in RR.poly_ring(x, y)) is True
assert (3.14 in EX) is True
assert (3.14 in ZZ) is False
assert (3.14 in QQ) is True
assert (3.14 in RR) is True
assert (3.14 in CC) is True
assert (3.14 in ALG) is True
assert (3.14 in ZZ.poly_ring(x, y)) is False
assert (3.14 in QQ.poly_ring(x, y)) is True
assert (3.14 in RR.poly_ring(x, y)) is True
assert (oo in EX) is True
assert (oo in ZZ) is False
assert (oo in QQ) is False
assert (oo in RR) is True
assert (oo in CC) is True
assert (oo in ALG) is False
assert (oo in ZZ.poly_ring(x, y)) is False
assert (oo in QQ.poly_ring(x, y)) is False
assert (oo in RR.poly_ring(x, y)) is True
assert (-oo in EX) is True
assert (-oo in ZZ) is False
assert (-oo in QQ) is False
assert (-oo in RR) is True
assert (-oo in CC) is True
assert (-oo in ALG) is False
assert (-oo in ZZ.poly_ring(x, y)) is False
assert (-oo in QQ.poly_ring(x, y)) is False
assert (-oo in RR.poly_ring(x, y)) is True
assert (sqrt(7) in EX) is True
assert (sqrt(7) in ZZ) is False
assert (sqrt(7) in QQ) is False
assert (sqrt(7) in RR) is True
assert (sqrt(7) in CC) is True
assert (sqrt(7) in ALG) is False
assert (sqrt(7) in ZZ.poly_ring(x, y)) is False
assert (sqrt(7) in QQ.poly_ring(x, y)) is False
assert (sqrt(7) in RR.poly_ring(x, y)) is True
assert (2*sqrt(3) + 1 in EX) is True
assert (2*sqrt(3) + 1 in ZZ) is False
assert (2*sqrt(3) + 1 in QQ) is False
assert (2*sqrt(3) + 1 in RR) is True
assert (2*sqrt(3) + 1 in CC) is True
assert (2*sqrt(3) + 1 in ALG) is True
assert (2*sqrt(3) + 1 in ZZ.poly_ring(x, y)) is False
assert (2*sqrt(3) + 1 in QQ.poly_ring(x, y)) is False
assert (2*sqrt(3) + 1 in RR.poly_ring(x, y)) is True
assert (sin(1) in EX) is True
assert (sin(1) in ZZ) is False
assert (sin(1) in QQ) is False
assert (sin(1) in RR) is True
assert (sin(1) in CC) is True
assert (sin(1) in ALG) is False
assert (sin(1) in ZZ.poly_ring(x, y)) is False
assert (sin(1) in QQ.poly_ring(x, y)) is False
assert (sin(1) in RR.poly_ring(x, y)) is True
assert (x**2 + 1 in EX) is True
assert (x**2 + 1 in ZZ) is False
assert (x**2 + 1 in QQ) is False
assert (x**2 + 1 in RR) is False
assert (x**2 + 1 in CC) is False
assert (x**2 + 1 in ALG) is False
assert (x**2 + 1 in ZZ.poly_ring(x)) is True
assert (x**2 + 1 in QQ.poly_ring(x)) is True
assert (x**2 + 1 in RR.poly_ring(x)) is True
assert (x**2 + 1 in ZZ.poly_ring(x, y)) is True
assert (x**2 + 1 in QQ.poly_ring(x, y)) is True
assert (x**2 + 1 in RR.poly_ring(x, y)) is True
assert (x**2 + y**2 in EX) is True
assert (x**2 + y**2 in ZZ) is False
assert (x**2 + y**2 in QQ) is False
assert (x**2 + y**2 in RR) is False
assert (x**2 + y**2 in CC) is False
assert (x**2 + y**2 in ALG) is False
assert (x**2 + y**2 in ZZ.poly_ring(x)) is False
assert (x**2 + y**2 in QQ.poly_ring(x)) is False
assert (x**2 + y**2 in RR.poly_ring(x)) is False
assert (x**2 + y**2 in ZZ.poly_ring(x, y)) is True
assert (x**2 + y**2 in QQ.poly_ring(x, y)) is True
assert (x**2 + y**2 in RR.poly_ring(x, y)) is True
assert (Rational(3, 2)*x/(y + 1) - z in QQ.poly_ring(x, y, z)) is False
def test_sympyissue_11538():
assert construct_domain(E)[0] == ZZ.poly_ring(E)
assert (construct_domain(x**2 + 2 * x + E) == (ZZ.poly_ring(
x, E), ZZ.poly_ring(x, E)(x**2 + 2 * x + E)))
assert (construct_domain(x + y + GoldenRatio) == (EX,
EX(x + y + GoldenRatio)))
def test_dmp_factor_list():
R, x = ring("x", ZZ)
assert R(0).factor_list() == (0, [])
assert R(7).factor_list() == (7, [])
R, x = ring("x", QQ)
assert R(0).factor_list() == (0, [])
assert R(QQ(1, 7)).factor_list() == (QQ(1, 7), [])
R, x = ring("x", ZZ.poly_ring('t'))
assert R(0).factor_list() == (0, [])
assert R(7).factor_list() == (7, [])
R, x = ring("x", QQ.poly_ring('t'))
assert R(0).factor_list() == (0, [])
assert R(QQ(1, 7)).factor_list() == (QQ(1, 7), [])
R, x = ring("x", ZZ)
assert (x**2 + 2 * x + 1).factor_list() == (1, [(x + 1, 2)])
# issue sympy/sympy#8037
assert (6 * x**2 - 5 * x - 6).factor_list() == (1, [(2 * x - 3, 1),
(3 * x + 2, 1)])
R, x = ring("x", QQ)
assert (x**2 / 2 + x + QQ(1, 2)).factor_list() == (QQ(1, 2), [(x + 1, 2)])
R, x = ring("x", FF(2))
assert (x**2 + 1).factor_list() == (1, [(x + 1, 2)])
R, x = ring("x", RR)
assert (1.0 * x**2 + 2.0 * x + 1.0).factor_list() == (1.0, [(1.0 * x + 1.0,
2)])
assert (2.0 * x**2 + 4.0 * x + 2.0).factor_list() == (2.0, [(1.0 * x + 1.0,
2)])
f = 6.7225336055071 * x**2 - 10.6463972754741 * x - 0.33469524022264
coeff, factors = f.factor_list()
assert coeff == 1.0 and len(factors) == 1 and factors[0][0].almosteq(
f, 1e-10) and factors[0][1] == 1
# issue diofant/diofant#238
f = 0.1 * x**2 + 1.1 * x + 1.0
assert f.factor_list() == (10.0, [(0.1 * x + 0.1, 1), (0.1 * x + 1.0, 1)])
f = 0.25 + 1.0 * x + 1.0 * x**2
assert f.factor_list() == (4.0, [(0.25 + 0.5 * x, 2)])
Rt, t = ring("t", ZZ)
R, x = ring("x", Rt)
f = 4 * t * x**2 + 4 * t**2 * x
assert f.factor_list() == (4 * t, [(x, 1), (x + t, 1)])
Rt, t = ring("t", QQ)
R, x = ring("x", Rt)
f = t * x**2 / 2 + t**2 * x / 2
assert f.factor_list() == (t / 2, [(x, 1), (x + t, 1)])
R, x = ring("x", QQ.algebraic_field(I))
f = x**4 + 2 * x**2
assert f.factor_list() == (1, [(x, 2), (x**2 + 2, 1)])
R, x = ring("x", EX)
pytest.raises(DomainError, lambda: R(EX(sin(1))).factor_list())
R, x, y = ring("x,y", ZZ)
assert R(0).factor_list() == (0, [])
assert R(7).factor_list() == (7, [])
R, x, y = ring("x,y", QQ)
assert R(0).factor_list() == (0, [])
assert R(QQ(1, 7)).factor_list() == (QQ(1, 7), [])
Rt, t = ring("t", ZZ)
R, x, y = ring("x,y", Rt)
assert R(0).factor_list() == (0, [])
assert R(7).factor_list() == (7, [])
Rt, t = ring("t", QQ)
R, x, y = ring("x,y", Rt)
assert R(0).factor_list() == (0, [])
assert R(QQ(1, 7)).factor_list() == (QQ(1, 7), [])
R, *X = ring("x:200", ZZ)
f, g = X[0]**2 + 2 * X[0] + 1, X[0] + 1
assert f.factor_list() == (1, [(g, 2)])
f, g = X[-1]**2 + 2 * X[-1] + 1, X[-1] + 1
assert f.factor_list() == (1, [(g, 2)])
R, x = ring("x", ZZ)
assert (x**2 + 2 * x + 1).factor_list() == (1, [(x + 1, 2)])
R, x = ring("x", QQ)
assert (x**2 / 2 + x + QQ(1, 2)).factor_list() == (QQ(1, 2), [(x + 1, 2)])
R, x, y = ring("x,y", ZZ)
assert (x**2 + 2 * x + 1).factor_list() == (1, [(x + 1, 2)])
R, x, y = ring("x,y", QQ)
assert (x**2 / 2 + x + QQ(1, 2)).factor_list() == (QQ(1, 2), [(x + 1, 2)])
R, x, y = ring("x,y", ZZ)
f = 4 * x**2 * y + 4 * x * y**2
assert f.factor_list() == (4, [(y, 1), (x, 1), (x + y, 1)])
R, x, y = ring("x,y", QQ)
f = x**2 * y / 2 + x * y**2 / 2
assert f.factor_list() == (QQ(1, 2), [(y, 1), (x, 1), (x + y, 1)])
R, x, y = ring("x,y", RR)
f = 2.0 * x**2 - 8.0 * y**2
assert f.factor_list() == (2.0, [(1.0 * x - 2.0 * y, 1),
(1.0 * x + 2.0 * y, 1)])
f = 6.7225336055071 * x**2 * y**2 - 10.6463972754741 * x * y - 0.33469524022264
coeff, factors = f.factor_list()
assert coeff == 1.0 and len(factors) == 1 and factors[0][0].almosteq(
f, 1e-10) and factors[0][1] == 1
# issue diofant/diofant#238
R, x, y, z = ring("x,y,z", RR)
f = x * y + x * z + 0.1 * y + 0.1 * z
assert f.factor_list() == (10.0, [(0.1 * y + 0.1 * z, 1), (x + 0.1, 1)])
f = 0.25 * x**2 + 1.0 * x * y * z + 1.0 * y**2 * z**2
assert f.factor_list() == (4.0, [(0.25 * x + 0.5 * y * z, 2)])
Rt, t = ring("t", ZZ)
R, x, y = ring("x,y", Rt)
f = 4 * t * x**2 + 4 * t**2 * x
assert f.factor_list() == (4 * t, [(x, 1), (x + t, 1)])
Rt, t = ring("t", QQ)
R, x, y = ring("x,y", Rt)
f = t * x**2 / 2 + t**2 * x / 2
assert f.factor_list() == (t / 2, [(x, 1), (x + t, 1)])
R, x, y = ring("x,y", FF(2))
pytest.raises(NotImplementedError, lambda: (x**2 + y**2).factor_list())
R, x, y = ring("x,y", EX)
pytest.raises(DomainError, lambda: R(EX(sin(1))).factor_list())
R, x, y = ring('x, y', QQ.algebraic_field(I))
f, r = x**2 + y**2, (1, [(x - I * y, 1), (x + I * y, 1)])
assert R.dmp_factor_list(f) == r
with config.using(aa_factor_method='trager'):
assert R.dmp_factor_list(f) == r