def test_Domain_get_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ[x].has_assoc_Ring is True
assert QQ[x].has_assoc_Ring is True
assert ZZ[x, y].has_assoc_Ring is True
assert QQ[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.get_ring() == ZZ
assert QQ.get_ring() == ZZ
assert ZZ[x].get_ring() == ZZ[x]
assert QQ[x].get_ring() == QQ[x]
assert ZZ[x, y].get_ring() == ZZ[x, y]
assert QQ[x, y].get_ring() == QQ[x, y]
assert ZZ.frac_field(x).get_ring() == ZZ[x]
assert QQ.frac_field(x).get_ring() == QQ[x]
assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
assert EX.get_ring() == EX
assert RR.get_ring() == RR
# XXX: This should also be like RR
raises(DomainError, lambda: ALG.get_ring())
def test_Domain_get_ring():
assert ZZ.has_assoc_Ring == True
assert QQ.has_assoc_Ring == True
assert ZZ[x].has_assoc_Ring == True
assert QQ[x].has_assoc_Ring == True
assert ZZ[x,y].has_assoc_Ring == True
assert QQ[x,y].has_assoc_Ring == True
assert ZZ.frac_field(x).has_assoc_Ring == True
assert QQ.frac_field(x).has_assoc_Ring == True
assert ZZ.frac_field(x,y).has_assoc_Ring == True
assert QQ.frac_field(x,y).has_assoc_Ring == True
assert EX.has_assoc_Ring == False
assert RR.has_assoc_Ring == False
assert ALG.has_assoc_Ring == False
assert ZZ.get_ring() == ZZ
assert QQ.get_ring() == ZZ
assert ZZ[x].get_ring() == ZZ[x]
assert QQ[x].get_ring() == QQ[x]
assert ZZ[x,y].get_ring() == ZZ[x,y]
assert QQ[x,y].get_ring() == QQ[x,y]
assert ZZ.frac_field(x).get_ring() == ZZ[x]
assert QQ.frac_field(x).get_ring() == QQ[x]
assert ZZ.frac_field(x,y).get_ring() == ZZ[x,y]
assert QQ.frac_field(x,y).get_ring() == QQ[x,y]
raises(DomainError, "EX.get_ring()")
raises(DomainError, "RR.get_ring()")
raises(DomainError, "ALG.get_ring()")
def test_Domain_get_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ[x].has_assoc_Ring is True
assert QQ[x].has_assoc_Ring is True
assert ZZ[x, y].has_assoc_Ring is True
assert QQ[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.get_ring() == ZZ
assert QQ.get_ring() == ZZ
assert ZZ[x].get_ring() == ZZ[x]
assert QQ[x].get_ring() == QQ[x]
assert ZZ[x, y].get_ring() == ZZ[x, y]
assert QQ[x, y].get_ring() == QQ[x, y]
assert ZZ.frac_field(x).get_ring() == ZZ[x]
assert QQ.frac_field(x).get_ring() == QQ[x]
assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
assert EX.get_ring() == EX
raises(DomainError, lambda: RR.get_ring())
raises(DomainError, lambda: ALG.get_ring())
def test_Domain_get_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ[x].has_assoc_Ring is True
assert QQ[x].has_assoc_Ring is True
assert ZZ[x, y].has_assoc_Ring is True
assert QQ[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.get_ring() == ZZ
assert QQ.get_ring() == ZZ
assert ZZ[x].get_ring() == ZZ[x]
assert QQ[x].get_ring() == QQ[x]
assert ZZ[x, y].get_ring() == ZZ[x, y]
assert QQ[x, y].get_ring() == QQ[x, y]
assert ZZ.frac_field(x).get_ring() == ZZ[x]
assert QQ.frac_field(x).get_ring() == QQ[x]
assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
assert EX.get_ring() == EX
raises(DomainError, lambda: RR.get_ring())
raises(DomainError, lambda: ALG.get_ring())
def test_Domain_get_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ[x].has_assoc_Ring is True
assert QQ[x].has_assoc_Ring is True
assert ZZ[x, y].has_assoc_Ring is True
assert QQ[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.get_ring() == ZZ
assert QQ.get_ring() == ZZ
assert ZZ[x].get_ring() == ZZ[x]
assert QQ[x].get_ring() == QQ[x]
assert ZZ[x, y].get_ring() == ZZ[x, y]
assert QQ[x, y].get_ring() == QQ[x, y]
assert ZZ.frac_field(x).get_ring() == ZZ[x]
assert QQ.frac_field(x).get_ring() == QQ[x]
assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
assert EX.get_ring() == EX
assert RR.get_ring() == RR
# XXX: This should also be like RR
raises(DomainError, lambda: ALG.get_ring())
def test_Domain_get_ring():
assert ZZ.has_assoc_Ring == True
assert QQ.has_assoc_Ring == True
assert ZZ[x].has_assoc_Ring == True
assert QQ[x].has_assoc_Ring == True
assert ZZ[x, y].has_assoc_Ring == True
assert QQ[x, y].has_assoc_Ring == True
assert ZZ.frac_field(x).has_assoc_Ring == True
assert QQ.frac_field(x).has_assoc_Ring == True
assert ZZ.frac_field(x, y).has_assoc_Ring == True
assert QQ.frac_field(x, y).has_assoc_Ring == True
assert EX.has_assoc_Ring == False
assert RR.has_assoc_Ring == False
assert ALG.has_assoc_Ring == False
assert ZZ.get_ring() == ZZ
assert QQ.get_ring() == ZZ
assert ZZ[x].get_ring() == ZZ[x]
assert QQ[x].get_ring() == QQ[x]
assert ZZ[x, y].get_ring() == ZZ[x, y]
assert QQ[x, y].get_ring() == QQ[x, y]
assert ZZ.frac_field(x).get_ring() == ZZ[x]
assert QQ.frac_field(x).get_ring() == QQ[x]
assert ZZ.frac_field(x, y).get_ring() == ZZ[x, y]
assert QQ.frac_field(x, y).get_ring() == QQ[x, y]
raises(DomainError, "EX.get_ring()")
raises(DomainError, "RR.get_ring()")
raises(DomainError, "ALG.get_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[x, y]) == ZZ[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)
raises(OptionError, lambda: Domain.preprocess('Z[]'))
assert Domain.preprocess('Z[x]') == ZZ[x]
assert Domain.preprocess('Q[x]') == QQ[x]
assert Domain.preprocess('ZZ[x]') == ZZ[x]
assert Domain.preprocess('QQ[x]') == QQ[x]
assert Domain.preprocess('Z[x,y]') == ZZ[x, y]
assert Domain.preprocess('Q[x,y]') == QQ[x, y]
assert Domain.preprocess('ZZ[x,y]') == ZZ[x, y]
assert Domain.preprocess('QQ[x,y]') == QQ[x, y]
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)
raises(OptionError, lambda: Domain.preprocess('abc'))
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[x, y]) == ZZ[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)
raises(OptionError, lambda: Domain.preprocess('Z[]'))
assert Domain.preprocess('Z[x]') == ZZ[x]
assert Domain.preprocess('Q[x]') == QQ[x]
assert Domain.preprocess('ZZ[x]') == ZZ[x]
assert Domain.preprocess('QQ[x]') == QQ[x]
assert Domain.preprocess('Z[x,y]') == ZZ[x, y]
assert Domain.preprocess('Q[x,y]') == QQ[x, y]
assert Domain.preprocess('ZZ[x,y]') == ZZ[x, y]
assert Domain.preprocess('QQ[x,y]') == QQ[x, y]
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)
raises(OptionError, lambda: Domain.preprocess('abc'))
def test_Domain___eq__():
assert (ZZ[x,y] == ZZ[x,y]) == True
assert (QQ[x,y] == QQ[x,y]) == True
assert (ZZ[x,y] == QQ[x,y]) == False
assert (QQ[x,y] == ZZ[x,y]) == False
assert (ZZ.frac_field(x,y) == ZZ.frac_field(x,y)) == True
assert (QQ.frac_field(x,y) == QQ.frac_field(x,y)) == True
assert (ZZ.frac_field(x,y) == QQ.frac_field(x,y)) == False
assert (QQ.frac_field(x,y) == ZZ.frac_field(x,y)) == False
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[x, y]) == ZZ[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)
raises(OptionError, "Domain.preprocess('Z[]')")
assert Domain.preprocess("Z[x]") == ZZ[x]
assert Domain.preprocess("Q[x]") == QQ[x]
assert Domain.preprocess("ZZ[x]") == ZZ[x]
assert Domain.preprocess("QQ[x]") == QQ[x]
assert Domain.preprocess("Z[x,y]") == ZZ[x, y]
assert Domain.preprocess("Q[x,y]") == QQ[x, y]
assert Domain.preprocess("ZZ[x,y]") == ZZ[x, y]
assert Domain.preprocess("QQ[x,y]") == QQ[x, y]
raises(OptionError, "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)
raises(OptionError, "Domain.preprocess('abc')")
def test_Domain___eq__():
assert (ZZ[x, y] == ZZ[x, y]) == True
assert (QQ[x, y] == QQ[x, y]) == True
assert (ZZ[x, y] == QQ[x, y]) == False
assert (QQ[x, y] == ZZ[x, y]) == False
assert (ZZ.frac_field(x, y) == ZZ.frac_field(x, y)) == True
assert (QQ.frac_field(x, y) == QQ.frac_field(x, y)) == True
assert (ZZ.frac_field(x, y) == QQ.frac_field(x, y)) == False
assert (QQ.frac_field(x, y) == ZZ.frac_field(x, y)) == False
def test_Domain___eq__():
assert (ZZ[x, y] == ZZ[x, y]) is True
assert (QQ[x, y] == QQ[x, y]) is True
assert (ZZ[x, y] == QQ[x, y]) is False
assert (QQ[x, y] == ZZ[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
assert RealField()[x] == RR[x]
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[x].get_exact() == ZZ[x]
assert QQ[x].get_exact() == QQ[x]
assert ZZ[x,y].get_exact() == ZZ[x,y]
assert QQ[x,y].get_exact() == QQ[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___eq__():
assert (ZZ[x, y] == ZZ[x, y]) is True
assert (QQ[x, y] == QQ[x, y]) is True
assert (ZZ[x, y] == QQ[x, y]) is False
assert (QQ[x, y] == ZZ[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
assert RealField()[x] == RR[x]
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[x].get_exact() == ZZ[x]
assert QQ[x].get_exact() == QQ[x]
assert ZZ[x, y].get_exact() == ZZ[x, y]
assert QQ[x, y].get_exact() == QQ[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_PrettyPoly():
from sympy.polys.domains import QQ
F = QQ.frac_field(x, y)
R = QQ[x, y]
assert latex(F.convert(x/(x + y))) == latex(x/(x + y))
assert latex(R.convert(x + y)) == latex(x + y)
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 1/(1 + x) in R
assert Y in R
assert X.ring == R
assert X*(Y**2+1)/(1 + X) == R.convert(x*(y**2 + 1)/(1 + x))
assert X*y == X*Y
raises(ExactQuotientFailed, lambda: X/Y)
raises(ExactQuotientFailed, lambda: x/Y)
raises(ExactQuotientFailed, lambda: X/y)
assert X + y == X + Y == R.convert(x + y) == x + Y
assert X - y == X - Y == R.convert(x - y) == x - Y
assert X + 1 == R.convert(x + 1)
assert X**2 / X == X
assert R.from_GlobalPolynomialRing(ZZ[x, y].convert(x), ZZ[x, y]) == X
assert R.from_FractionField(Qxy.convert(x), Qxy) == X
raises(CoercionFailed, lambda: R.from_FractionField(Qxy.convert(x)/y, Qxy))
raises(ExactQuotientFailed, lambda: X/Y)
raises(NotReversible, lambda: X.invert())
assert R._sdm_to_vector(R._vector_to_sdm([X/(X + 1), Y/(1 + X*Y)], R.order),
2) == \
[X*(1 + X*Y), Y*(1 + X)]
def test_globalring():
Qxy = QQ.frac_field(x, y)
R = QQ[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
assert X * (Y**2 + 1) == R.convert(x * (y**2 + 1))
assert X * y == X * Y == R.convert(x * y) == x * Y
assert X + y == X + Y == R.convert(x + y) == x + Y
assert X - y == X - Y == R.convert(x - y) == x - Y
assert X + 1 == R.convert(x + 1)
raises(ExactQuotientFailed, lambda: X/Y)
raises(ExactQuotientFailed, lambda: x/Y)
raises(ExactQuotientFailed, lambda: X/y)
assert X**2 / X == X
assert R.from_GlobalPolynomialRing(ZZ[x, y].convert(x), ZZ[x, y]) == X
assert R.from_FractionField(Qxy.convert(x), Qxy) == X
assert R.from_FractionField(Qxy.convert(x)/y, Qxy) is None
assert R._sdm_to_vector(R._vector_to_sdm([X, Y], R.order), 2) == [X, Y]
def test_PrettyPoly():
from sympy.polys.domains import QQ
F = QQ.frac_field(x, y)
R = QQ[x, y]
assert latex(F.convert(x / (x + y))) == latex(x / (x + y))
assert latex(R.convert(x + y)) == latex(x + y)
def test_Domain_convert():
def check_element(e1, e2, K1, K2, K3):
assert type(e1) is type(e2), '%s, %s: %s %s -> %s' % (e1, e2, K1, K2,
K3)
assert e1 == e2, '%s, %s: %s %s -> %s' % (e1, e2, K1, K2, K3)
def check_domains(K1, K2):
K3 = K1.unify(K2)
check_element(K3.convert_from(K1.one, K1), K3.one, K1, K2, K3)
check_element(K3.convert_from(K2.one, K2), K3.one, K1, K2, K3)
check_element(K3.convert_from(K1.zero, K1), K3.zero, K1, K2, K3)
check_element(K3.convert_from(K2.zero, K2), K3.zero, K1, K2, K3)
def composite_domains(K):
domains = [
K,
K[y],
K[z],
K[y, z],
K.frac_field(y),
K.frac_field(z),
K.frac_field(y, z),
# XXX: These should be tested and made to work...
# K.old_poly_ring(y), K.old_frac_field(y),
]
return domains
QQ2 = QQ.algebraic_field(sqrt(2))
QQ3 = QQ.algebraic_field(sqrt(3))
doms = [ZZ, QQ, QQ2, QQ3, QQ_I, ZZ_I, RR, CC]
for i, K1 in enumerate(doms):
for K2 in doms[i:]:
for K3 in composite_domains(K1):
for K4 in composite_domains(K2):
check_domains(K3, K4)
assert QQ.convert(10e-52) == QQ(
1684996666696915,
1684996666696914987166688442938726917102321526408785780068975640576)
R, xr = ring("x", ZZ)
assert ZZ.convert(xr - xr) == 0
assert ZZ.convert(xr - xr, R.to_domain()) == 0
assert CC.convert(ZZ_I(1, 2)) == CC(1, 2)
assert CC.convert(QQ_I(1, 2)) == CC(1, 2)
K1 = QQ.frac_field(x)
K2 = ZZ.frac_field(x)
K3 = QQ[x]
K4 = ZZ[x]
Ks = [K1, K2, K3, K4]
for Ka, Kb in product(Ks, Ks):
assert Ka.convert_from(Kb.from_sympy(x), Kb) == Ka.from_sympy(x)
assert K2.convert_from(QQ(1, 2), QQ) == K2(QQ(1, 2))
def test_Domain_get_field():
assert EX.has_assoc_Field == True
assert ZZ.has_assoc_Field == True
assert QQ.has_assoc_Field == True
assert RR.has_assoc_Field == False
assert ALG.has_assoc_Field == True
assert ZZ[x].has_assoc_Field == True
assert QQ[x].has_assoc_Field == True
assert ZZ[x,y].has_assoc_Field == True
assert QQ[x,y].has_assoc_Field == True
assert EX.get_field() == EX
assert ZZ.get_field() == QQ
assert QQ.get_field() == QQ
raises(DomainError, "RR.get_field()")
assert ALG.get_field() == ALG
assert ZZ[x].get_field() == ZZ.frac_field(x)
assert QQ[x].get_field() == QQ.frac_field(x)
assert ZZ[x,y].get_field() == ZZ.frac_field(x,y)
assert QQ[x,y].get_field() == QQ.frac_field(x,y)
def test_Domain_get_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[x].has_assoc_Field is True
assert QQ[x].has_assoc_Field is True
assert ZZ[x, y].has_assoc_Field is True
assert QQ[x, y].has_assoc_Field is True
assert EX.get_field() == EX
assert ZZ.get_field() == QQ
assert QQ.get_field() == QQ
assert RR.get_field() == RR
assert ALG.get_field() == ALG
assert ZZ[x].get_field() == ZZ.frac_field(x)
assert QQ[x].get_field() == QQ.frac_field(x)
assert ZZ[x, y].get_field() == ZZ.frac_field(x, y)
assert QQ[x, y].get_field() == QQ.frac_field(x, y)
def test_Domain_get_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[x].has_assoc_Field is True
assert QQ[x].has_assoc_Field is True
assert ZZ[x, y].has_assoc_Field is True
assert QQ[x, y].has_assoc_Field is True
assert EX.get_field() == EX
assert ZZ.get_field() == QQ
assert QQ.get_field() == QQ
assert RR.get_field() == RR
assert ALG.get_field() == ALG
assert ZZ[x].get_field() == ZZ.frac_field(x)
assert QQ[x].get_field() == QQ.frac_field(x)
assert ZZ[x, y].get_field() == ZZ.frac_field(x, y)
assert QQ[x, y].get_field() == QQ.frac_field(x, y)
def test_Domain_get_field():
assert EX.has_assoc_Field == True
assert ZZ.has_assoc_Field == True
assert QQ.has_assoc_Field == True
assert RR.has_assoc_Field == False
assert ALG.has_assoc_Field == True
assert ZZ[x].has_assoc_Field == True
assert QQ[x].has_assoc_Field == True
assert ZZ[x, y].has_assoc_Field == True
assert QQ[x, y].has_assoc_Field == True
assert EX.get_field() == EX
assert ZZ.get_field() == QQ
assert QQ.get_field() == QQ
raises(DomainError, "RR.get_field()")
assert ALG.get_field() == ALG
assert ZZ[x].get_field() == ZZ.frac_field(x)
assert QQ[x].get_field() == QQ.frac_field(x)
assert ZZ[x, y].get_field() == ZZ.frac_field(x, y)
assert QQ[x, y].get_field() == QQ.frac_field(x, y)
def test_Domain_is_unit():
nums = [-2, -1, 0, 1, 2]
invring = [False, True, False, True, False]
invfield = [True, True, False, True, True]
ZZx, QQx, QQxf = ZZ[x], QQ[x], QQ.frac_field(x)
assert [ZZ.is_unit(ZZ(n)) for n in nums] == invring
assert [QQ.is_unit(QQ(n)) for n in nums] == invfield
assert [ZZx.is_unit(ZZx(n)) for n in nums] == invring
assert [QQx.is_unit(QQx(n)) for n in nums] == invfield
assert [QQxf.is_unit(QQxf(n)) for n in nums] == invfield
assert ZZx.is_unit(ZZx(x)) is False
assert QQx.is_unit(QQx(x)) is False
assert QQxf.is_unit(QQxf(x)) is True
def test_globalring():
Qxy = QQ.frac_field(x, y)
R = QQ[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
assert X * (Y**2 + 1) == R.convert(x * (y**2 + 1))
assert X * y == X * Y == R.convert(x * y) == x * Y
assert X + y == X + Y == R.convert(x + y) == x + Y
assert X + 1 == R.convert(x + 1)
raises(ExactQuotientFailed, 'X/Y')
raises(ExactQuotientFailed, 'x/Y')
raises(ExactQuotientFailed, 'X/y')
assert X**2 / X == X
assert R.from_GlobalPolynomialRing(ZZ[x, y].convert(x), ZZ[x, y]) == X
assert R.from_FractionField(Qxy.convert(x), Qxy) == X
assert R.from_FractionField(Qxy.convert(x)/y, Qxy) is None
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 1/(1 + x) in R
assert Y in R
assert X.ring == R
assert X*(Y**2+1)/(1 + X) == R.convert(x*(y**2 + 1)/(1 + x))
assert X*y == X*Y
raises(ExactQuotientFailed, 'X/Y')
raises(ExactQuotientFailed, 'x/Y')
raises(ExactQuotientFailed, 'X/y')
assert X + y == X + Y == R.convert(x + y) == x + Y
assert X + 1 == R.convert(x + 1)
assert X**2 / X == X
assert R.from_GlobalPolynomialRing(ZZ[x, y].convert(x), ZZ[x, y]) == X
assert R.from_FractionField(Qxy.convert(x), Qxy) == X
raises(CoercionFailed, 'R.from_FractionField(Qxy.convert(x)/y, Qxy)')
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 1/(1 + x) in R
assert Y in R
assert X.ring == R
assert X*(Y**2+1)/(1 + X) == R.convert(x*(y**2 + 1)/(1 + x))
assert X*y == X*Y
raises(ExactQuotientFailed, lambda: X/Y)
raises(ExactQuotientFailed, lambda: x/Y)
raises(ExactQuotientFailed, lambda: X/y)
assert X + y == X + Y == R.convert(x + y) == x + Y
assert X + 1 == R.convert(x + 1)
assert X**2 / X == X
assert R.from_GlobalPolynomialRing(ZZ[x, y].convert(x), ZZ[x, y]) == X
assert R.from_FractionField(Qxy.convert(x), Qxy) == X
raises(CoercionFailed, lambda: R.from_FractionField(Qxy.convert(x)/y, Qxy))
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_Domain__unify():
assert ZZ.unify(ZZ) == ZZ
assert QQ.unify(QQ) == QQ
assert ZZ.unify(QQ) == QQ
assert QQ.unify(ZZ) == QQ
assert EX.unify(EX) == EX
assert ZZ.unify(EX) == EX
assert QQ.unify(EX) == EX
assert EX.unify(ZZ) == EX
assert EX.unify(QQ) == EX
assert ZZ.poly_ring(x).unify(EX) == EX
assert ZZ.frac_field(x).unify(EX) == EX
assert EX.unify(ZZ.poly_ring(x)) == EX
assert EX.unify(ZZ.frac_field(x)) == EX
assert ZZ.poly_ring(x, y).unify(EX) == EX
assert ZZ.frac_field(x, y).unify(EX) == EX
assert EX.unify(ZZ.poly_ring(x, y)) == EX
assert EX.unify(ZZ.frac_field(x, y)) == EX
assert QQ.poly_ring(x).unify(EX) == EX
assert QQ.frac_field(x).unify(EX) == EX
assert EX.unify(QQ.poly_ring(x)) == EX
assert EX.unify(QQ.frac_field(x)) == EX
assert QQ.poly_ring(x, y).unify(EX) == EX
assert QQ.frac_field(x, y).unify(EX) == EX
assert EX.unify(QQ.poly_ring(x, y)) == EX
assert EX.unify(QQ.frac_field(x, y)) == EX
assert ZZ.poly_ring(x).unify(ZZ) == ZZ.poly_ring(x)
assert ZZ.poly_ring(x).unify(QQ) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(ZZ) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(QQ) == QQ.poly_ring(x)
assert ZZ.unify(ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert QQ.unify(ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert ZZ.unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert QQ.unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).unify(ZZ) == ZZ.poly_ring(x, y)
assert ZZ.poly_ring(x, y).unify(QQ) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(ZZ) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(QQ) == QQ.poly_ring(x, y)
assert ZZ.unify(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert QQ.unify(ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert ZZ.unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert QQ.unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert ZZ.frac_field(x).unify(ZZ) == ZZ.frac_field(x)
assert ZZ.frac_field(x).unify(QQ) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(ZZ) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(QQ) == QQ.frac_field(x)
assert ZZ.unify(ZZ.frac_field(x)) == ZZ.frac_field(x)
assert QQ.unify(ZZ.frac_field(x)) == EX # QQ.frac_field(x)
assert ZZ.unify(QQ.frac_field(x)) == EX # QQ.frac_field(x)
assert QQ.unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert ZZ.frac_field(x, y).unify(ZZ) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(QQ) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(ZZ) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(QQ) == QQ.frac_field(x, y)
assert ZZ.unify(ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert QQ.unify(ZZ.frac_field(x, y)) == EX # QQ.frac_field(x,y)
assert ZZ.unify(QQ.frac_field(x, y)) == EX # QQ.frac_field(x,y)
assert QQ.unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert ZZ.poly_ring(x).unify(ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert ZZ.poly_ring(x).unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).unify(ZZ.poly_ring(x)) == ZZ.poly_ring(x, y)
assert ZZ.poly_ring(x, y).unify(QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(ZZ.poly_ring(x)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert ZZ.poly_ring(x).unify(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert ZZ.poly_ring(x).unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x).unify(ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x).unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert ZZ.poly_ring(x, y).unify(ZZ.poly_ring(x, z)) == ZZ.poly_ring(x, y, z)
assert ZZ.poly_ring(x, y).unify(QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
assert QQ.poly_ring(x, y).unify(ZZ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
assert QQ.poly_ring(x, y).unify(QQ.poly_ring(x, z)) == QQ.poly_ring(x, y, z)
assert ZZ.frac_field(x).unify(ZZ.frac_field(x)) == ZZ.frac_field(x)
assert ZZ.frac_field(x).unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert QQ.frac_field(x).unify(ZZ.frac_field(x)) == QQ.frac_field(x)
assert QQ.frac_field(x).unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert ZZ.frac_field(x, y).unify(ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(QQ.frac_field(x)) == QQ.frac_field(x, y)
assert QQ.frac_field(x, y).unify(ZZ.frac_field(x)) == QQ.frac_field(x, y)
assert QQ.frac_field(x, y).unify(QQ.frac_field(x)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x).unify(ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x).unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert QQ.frac_field(x).unify(ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
assert QQ.frac_field(x).unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert ZZ.frac_field(x, y).unify(QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert QQ.frac_field(x, y).unify(ZZ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert QQ.frac_field(x, y).unify(QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert ZZ.poly_ring(x).unify(ZZ.frac_field(x)) == ZZ.frac_field(x)
assert ZZ.poly_ring(x).unify(QQ.frac_field(x)) == EX # QQ.frac_field(x)
assert QQ.poly_ring(x).unify(ZZ.frac_field(x)) == EX # QQ.frac_field(x)
assert QQ.poly_ring(x).unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert ZZ.poly_ring(x, y).unify(ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert ZZ.poly_ring(x, y).unify(QQ.frac_field(x)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x, y).unify(ZZ.frac_field(x)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x, y).unify(QQ.frac_field(x)) == QQ.frac_field(x, y)
assert ZZ.poly_ring(x).unify(ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert ZZ.poly_ring(x).unify(QQ.frac_field(x, y)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x).unify(ZZ.frac_field(x, y)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x).unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert ZZ.poly_ring(x, y).unify(ZZ.frac_field(x, z)) == ZZ.frac_field(x, y, z)
assert ZZ.poly_ring(x, y).unify(QQ.frac_field(x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.poly_ring(x, y).unify(ZZ.frac_field(x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.poly_ring(x, y).unify(QQ.frac_field(x, z)) == QQ.frac_field(x, y, z)
assert ZZ.frac_field(x).unify(ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert ZZ.frac_field(x).unify(QQ.poly_ring(x)) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(ZZ.poly_ring(x)) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(QQ.poly_ring(x)) == QQ.frac_field(x)
assert ZZ.frac_field(x, y).unify(ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(QQ.poly_ring(x)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(ZZ.poly_ring(x)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(QQ.poly_ring(x)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x).unify(ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x).unify(QQ.poly_ring(x, y)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x).unify(ZZ.poly_ring(x, y)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x).unify(QQ.poly_ring(x, y)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(ZZ.poly_ring(x, z)) == ZZ.frac_field(x, y, z)
assert ZZ.frac_field(x, y).unify(QQ.poly_ring(x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.frac_field(x, y).unify(ZZ.poly_ring(x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.frac_field(x, y).unify(QQ.poly_ring(x, z)) == QQ.frac_field(x, y, z)
alg = QQ.algebraic_field(sqrt(5))
assert alg.unify(alg[x, y]) == alg[x, y]
assert alg[x, y].unify(alg) == alg[x, y]
assert alg.unify(alg.frac_field(x, y)) == alg.frac_field(x, y)
assert alg.frac_field(x, y).unify(alg) == alg.frac_field(x, y)
ext = QQ.algebraic_field(sqrt(7))
raises(NotImplementedError, lambda: alg.unify(ext))
raises(UnificationFailed, lambda: ZZ.poly_ring(x, y).unify(ZZ, gens=(y, z)))
raises(UnificationFailed, lambda: ZZ.unify(ZZ.poly_ring(x, y), gens=(y, z)))
def test_Domain__unify():
assert ZZ.unify(ZZ) == ZZ
assert QQ.unify(QQ) == QQ
assert ZZ.unify(QQ) == QQ
assert QQ.unify(ZZ) == QQ
assert EX.unify(EX) == EX
assert ZZ.unify(EX) == EX
assert QQ.unify(EX) == EX
assert EX.unify(ZZ) == EX
assert EX.unify(QQ) == EX
assert ZZ.poly_ring('x').unify(EX) == EX
assert ZZ.frac_field('x').unify(EX) == EX
assert EX.unify(ZZ.poly_ring('x')) == EX
assert EX.unify(ZZ.frac_field('x')) == EX
assert ZZ.poly_ring('x', 'y').unify(EX) == EX
assert ZZ.frac_field('x', 'y').unify(EX) == EX
assert EX.unify(ZZ.poly_ring('x', 'y')) == EX
assert EX.unify(ZZ.frac_field('x', 'y')) == EX
assert QQ.poly_ring('x').unify(EX) == EX
assert QQ.frac_field('x').unify(EX) == EX
assert EX.unify(QQ.poly_ring('x')) == EX
assert EX.unify(QQ.frac_field('x')) == EX
assert QQ.poly_ring('x', 'y').unify(EX) == EX
assert QQ.frac_field('x', 'y').unify(EX) == EX
assert EX.unify(QQ.poly_ring('x', 'y')) == EX
assert EX.unify(QQ.frac_field('x', 'y')) == EX
assert ZZ.poly_ring('x').unify(ZZ) == ZZ.poly_ring('x')
assert ZZ.poly_ring('x').unify(QQ) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(ZZ) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(QQ) == QQ.poly_ring('x')
assert ZZ.unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x')
assert QQ.unify(ZZ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.poly_ring('x', 'y').unify(ZZ) == ZZ.poly_ring('x', 'y')
assert ZZ.poly_ring('x', 'y').unify(QQ) == QQ.poly_ring('x', 'y')
assert QQ.poly_ring('x', 'y').unify(ZZ) == QQ.poly_ring('x', 'y')
assert QQ.poly_ring('x', 'y').unify(QQ) == QQ.poly_ring('x', 'y')
assert ZZ.unify(ZZ.poly_ring('x', 'y')) == ZZ.poly_ring('x', 'y')
assert QQ.unify(ZZ.poly_ring('x', 'y')) == QQ.poly_ring('x', 'y')
assert ZZ.unify(QQ.poly_ring('x', 'y')) == QQ.poly_ring('x', 'y')
assert QQ.unify(QQ.poly_ring('x', 'y')) == QQ.poly_ring('x', 'y')
assert ZZ.frac_field('x').unify(ZZ) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ) == QQ.frac_field('x')
assert ZZ.unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert QQ.unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x')
assert ZZ.unify(QQ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x', 'y').unify(ZZ) == ZZ.frac_field('x', 'y')
assert ZZ.frac_field('x', 'y').unify(QQ) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x', 'y').unify(ZZ) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x', 'y').unify(QQ) == QQ.frac_field('x', 'y')
assert ZZ.unify(ZZ.frac_field('x', 'y')) == ZZ.frac_field('x', 'y')
assert QQ.unify(ZZ.frac_field('x', 'y')) == EX # QQ.frac_field('x','y')
assert ZZ.unify(QQ.frac_field('x', 'y')) == EX # QQ.frac_field('x','y')
assert QQ.unify(QQ.frac_field('x', 'y')) == QQ.frac_field('x', 'y')
assert ZZ.poly_ring('x').unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x')
assert ZZ.poly_ring('x').unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(ZZ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.poly_ring('x', 'y').unify(ZZ.poly_ring('x')) == ZZ.poly_ring(
'x', 'y')
assert ZZ.poly_ring('x', 'y').unify(QQ.poly_ring('x')) == QQ.poly_ring(
'x', 'y')
assert QQ.poly_ring('x', 'y').unify(ZZ.poly_ring('x')) == QQ.poly_ring(
'x', 'y')
assert QQ.poly_ring('x', 'y').unify(QQ.poly_ring('x')) == QQ.poly_ring(
'x', 'y')
assert ZZ.poly_ring('x').unify(ZZ.poly_ring('x', 'y')) == ZZ.poly_ring(
'x', 'y')
assert ZZ.poly_ring('x').unify(QQ.poly_ring('x', 'y')) == QQ.poly_ring(
'x', 'y')
assert QQ.poly_ring('x').unify(ZZ.poly_ring('x', 'y')) == QQ.poly_ring(
'x', 'y')
assert QQ.poly_ring('x').unify(QQ.poly_ring('x', 'y')) == QQ.poly_ring(
'x', 'y')
assert ZZ.poly_ring('x', 'y').unify(ZZ.poly_ring('x',
'z')) == ZZ.poly_ring(
'x', 'y', 'z')
assert ZZ.poly_ring('x', 'y').unify(QQ.poly_ring('x',
'z')) == QQ.poly_ring(
'x', 'y', 'z')
assert QQ.poly_ring('x', 'y').unify(ZZ.poly_ring('x',
'z')) == QQ.poly_ring(
'x', 'y', 'z')
assert QQ.poly_ring('x', 'y').unify(QQ.poly_ring('x',
'z')) == QQ.poly_ring(
'x', 'y', 'z')
assert ZZ.frac_field('x').unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ.frac_field('x')) == QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x', 'y').unify(ZZ.frac_field('x')) == ZZ.frac_field(
'x', 'y')
assert ZZ.frac_field('x', 'y').unify(QQ.frac_field('x')) == QQ.frac_field(
'x', 'y')
assert QQ.frac_field('x', 'y').unify(ZZ.frac_field('x')) == QQ.frac_field(
'x', 'y')
assert QQ.frac_field('x', 'y').unify(QQ.frac_field('x')) == QQ.frac_field(
'x', 'y')
assert ZZ.frac_field('x').unify(ZZ.frac_field('x', 'y')) == ZZ.frac_field(
'x', 'y')
assert ZZ.frac_field('x').unify(QQ.frac_field('x', 'y')) == QQ.frac_field(
'x', 'y')
assert QQ.frac_field('x').unify(ZZ.frac_field('x', 'y')) == QQ.frac_field(
'x', 'y')
assert QQ.frac_field('x').unify(QQ.frac_field('x', 'y')) == QQ.frac_field(
'x', 'y')
assert ZZ.frac_field('x', 'y').unify(ZZ.frac_field('x',
'z')) == ZZ.frac_field(
'x', 'y', 'z')
assert ZZ.frac_field('x', 'y').unify(QQ.frac_field('x',
'z')) == QQ.frac_field(
'x', 'y', 'z')
assert QQ.frac_field('x', 'y').unify(ZZ.frac_field('x',
'z')) == QQ.frac_field(
'x', 'y', 'z')
assert QQ.frac_field('x', 'y').unify(QQ.frac_field('x',
'z')) == QQ.frac_field(
'x', 'y', 'z')
assert ZZ.poly_ring('x').unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert ZZ.poly_ring('x').unify(
QQ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.poly_ring('x').unify(
ZZ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.poly_ring('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.poly_ring('x', 'y').unify(ZZ.frac_field('x')) == ZZ.frac_field(
'x', 'y')
assert ZZ.poly_ring('x', 'y').unify(
QQ.frac_field('x')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x', 'y').unify(
ZZ.frac_field('x')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x', 'y').unify(QQ.frac_field('x')) == QQ.frac_field(
'x', 'y')
assert ZZ.poly_ring('x').unify(ZZ.frac_field('x', 'y')) == ZZ.frac_field(
'x', 'y')
assert ZZ.poly_ring('x').unify(QQ.frac_field(
'x', 'y')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x').unify(ZZ.frac_field(
'x', 'y')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x').unify(QQ.frac_field('x', 'y')) == QQ.frac_field(
'x', 'y')
assert ZZ.poly_ring('x', 'y').unify(ZZ.frac_field('x',
'z')) == ZZ.frac_field(
'x', 'y', 'z')
assert ZZ.poly_ring('x', 'y').unify(QQ.frac_field(
'x', 'z')) == EX # QQ.frac_field('x','y','z')
assert QQ.poly_ring('x', 'y').unify(ZZ.frac_field(
'x', 'z')) == EX # QQ.frac_field('x','y','z')
assert QQ.poly_ring('x', 'y').unify(QQ.frac_field('x',
'z')) == QQ.frac_field(
'x', 'y', 'z')
assert ZZ.frac_field('x').unify(ZZ.poly_ring('x')) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(
QQ.poly_ring('x')) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(
ZZ.poly_ring('x')) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ.poly_ring('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x', 'y').unify(ZZ.poly_ring('x')) == ZZ.frac_field(
'x', 'y')
assert ZZ.frac_field('x', 'y').unify(
QQ.poly_ring('x')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x', 'y').unify(
ZZ.poly_ring('x')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x', 'y').unify(QQ.poly_ring('x')) == QQ.frac_field(
'x', 'y')
assert ZZ.frac_field('x').unify(ZZ.poly_ring('x', 'y')) == ZZ.frac_field(
'x', 'y')
assert ZZ.frac_field('x').unify(QQ.poly_ring(
'x', 'y')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(ZZ.poly_ring(
'x', 'y')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(QQ.poly_ring('x', 'y')) == QQ.frac_field(
'x', 'y')
assert ZZ.frac_field('x', 'y').unify(ZZ.poly_ring('x',
'z')) == ZZ.frac_field(
'x', 'y', 'z')
assert ZZ.frac_field('x', 'y').unify(QQ.poly_ring(
'x', 'z')) == EX # QQ.frac_field('x','y','z')
assert QQ.frac_field('x', 'y').unify(ZZ.poly_ring(
'x', 'z')) == EX # QQ.frac_field('x','y','z')
assert QQ.frac_field('x', 'y').unify(QQ.poly_ring('x',
'z')) == QQ.frac_field(
'x', 'y', 'z')
alg = QQ.algebraic_field(sqrt(5))
assert alg.unify(alg['x', 'y']) == alg['x', 'y']
assert alg['x', 'y'].unify(alg) == alg['x', 'y']
assert alg.unify(alg.frac_field('x', 'y')) == alg.frac_field('x', 'y')
assert alg.frac_field('x', 'y').unify(alg) == alg.frac_field('x', 'y')
ext = QQ.algebraic_field(sqrt(7))
raises(NotImplementedError, "alg.unify(ext)")
raises(UnificationFailed,
"ZZ.poly_ring('x','y').unify(ZZ, gens=('y', 'z'))")
raises(UnificationFailed,
"ZZ.unify(ZZ.poly_ring('x','y'), gens=('y', 'z'))")
def test_FractionField_convert():
K = QQ.frac_field(x)
assert K.convert(QQ(2, 3), QQ) == K.from_sympy(Rational(2, 3))
K = QQ.frac_field(x)
assert K.convert(ZZ(2), ZZ) == K.from_sympy(Integer(2))
def test_Domain__unify():
assert ZZ.unify(ZZ) == ZZ
assert QQ.unify(QQ) == QQ
assert ZZ.unify(QQ) == QQ
assert QQ.unify(ZZ) == QQ
assert EX.unify(EX) == EX
assert ZZ.unify(EX) == EX
assert QQ.unify(EX) == EX
assert EX.unify(ZZ) == EX
assert EX.unify(QQ) == EX
assert ZZ.poly_ring('x').unify(EX) == EX
assert ZZ.frac_field('x').unify(EX) == EX
assert EX.unify(ZZ.poly_ring('x')) == EX
assert EX.unify(ZZ.frac_field('x')) == EX
assert ZZ.poly_ring('x','y').unify(EX) == EX
assert ZZ.frac_field('x','y').unify(EX) == EX
assert EX.unify(ZZ.poly_ring('x','y')) == EX
assert EX.unify(ZZ.frac_field('x','y')) == EX
assert QQ.poly_ring('x').unify(EX) == EX
assert QQ.frac_field('x').unify(EX) == EX
assert EX.unify(QQ.poly_ring('x')) == EX
assert EX.unify(QQ.frac_field('x')) == EX
assert QQ.poly_ring('x','y').unify(EX) == EX
assert QQ.frac_field('x','y').unify(EX) == EX
assert EX.unify(QQ.poly_ring('x','y')) == EX
assert EX.unify(QQ.frac_field('x','y')) == EX
assert ZZ.poly_ring('x').unify(ZZ) == ZZ.poly_ring('x')
assert ZZ.poly_ring('x').unify(QQ) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(ZZ) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(QQ) == QQ.poly_ring('x')
assert ZZ.unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x')
assert QQ.unify(ZZ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.poly_ring('x','y').unify(ZZ) == ZZ.poly_ring('x','y')
assert ZZ.poly_ring('x','y').unify(QQ) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(ZZ) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(QQ) == QQ.poly_ring('x','y')
assert ZZ.unify(ZZ.poly_ring('x','y')) == ZZ.poly_ring('x','y')
assert QQ.unify(ZZ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert ZZ.unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert QQ.unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert ZZ.frac_field('x').unify(ZZ) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ) == QQ.frac_field('x')
assert ZZ.unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert QQ.unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x')
assert ZZ.unify(QQ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x','y').unify(ZZ) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(QQ) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(ZZ) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(QQ) == QQ.frac_field('x','y')
assert ZZ.unify(ZZ.frac_field('x','y')) == ZZ.frac_field('x','y')
assert QQ.unify(ZZ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert ZZ.unify(QQ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert ZZ.poly_ring('x').unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x')
assert ZZ.poly_ring('x').unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(ZZ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.poly_ring('x','y').unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x','y')
assert ZZ.poly_ring('x','y').unify(QQ.poly_ring('x')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(ZZ.poly_ring('x')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(QQ.poly_ring('x')) == QQ.poly_ring('x','y')
assert ZZ.poly_ring('x').unify(ZZ.poly_ring('x','y')) == ZZ.poly_ring('x','y')
assert ZZ.poly_ring('x').unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x').unify(ZZ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x').unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert ZZ.poly_ring('x','y').unify(ZZ.poly_ring('x','z')) == ZZ.poly_ring('x','y','z')
assert ZZ.poly_ring('x','y').unify(QQ.poly_ring('x','z')) == QQ.poly_ring('x','y','z')
assert QQ.poly_ring('x','y').unify(ZZ.poly_ring('x','z')) == QQ.poly_ring('x','y','z')
assert QQ.poly_ring('x','y').unify(QQ.poly_ring('x','z')) == QQ.poly_ring('x','y','z')
assert ZZ.frac_field('x').unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ.frac_field('x')) == QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x','y').unify(ZZ.frac_field('x')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(QQ.frac_field('x')) == QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(ZZ.frac_field('x')) == QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(QQ.frac_field('x')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x').unify(ZZ.frac_field('x','y')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x').unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(ZZ.frac_field('x','y')) == QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(ZZ.frac_field('x','z')) == ZZ.frac_field('x','y','z')
assert ZZ.frac_field('x','y').unify(QQ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(ZZ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(QQ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert ZZ.poly_ring('x').unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert ZZ.poly_ring('x').unify(QQ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.poly_ring('x').unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.poly_ring('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.poly_ring('x','y').unify(ZZ.frac_field('x')) == ZZ.frac_field('x','y')
assert ZZ.poly_ring('x','y').unify(QQ.frac_field('x')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x','y').unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x','y').unify(QQ.frac_field('x')) == QQ.frac_field('x','y')
assert ZZ.poly_ring('x').unify(ZZ.frac_field('x','y')) == ZZ.frac_field('x','y')
assert ZZ.poly_ring('x').unify(QQ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x').unify(ZZ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x').unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert ZZ.poly_ring('x','y').unify(ZZ.frac_field('x','z')) == ZZ.frac_field('x','y','z')
assert ZZ.poly_ring('x','y').unify(QQ.frac_field('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.poly_ring('x','y').unify(ZZ.frac_field('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.poly_ring('x','y').unify(QQ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert ZZ.frac_field('x').unify(ZZ.poly_ring('x')) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ.poly_ring('x')) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ.poly_ring('x')) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ.poly_ring('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x','y').unify(ZZ.poly_ring('x')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(QQ.poly_ring('x')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(ZZ.poly_ring('x')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(QQ.poly_ring('x')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x').unify(ZZ.poly_ring('x','y')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x').unify(QQ.poly_ring('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(ZZ.poly_ring('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(QQ.poly_ring('x','y')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(ZZ.poly_ring('x','z')) == ZZ.frac_field('x','y','z')
assert ZZ.frac_field('x','y').unify(QQ.poly_ring('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(ZZ.poly_ring('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(QQ.poly_ring('x','z')) == QQ.frac_field('x','y','z')
raises(UnificationFailed, "ZZ.poly_ring('x','y').unify(ZZ, gens=('y', 'z'))")
raises(UnificationFailed, "ZZ.unify(ZZ.poly_ring('x','y'), gens=('y', 'z'))")
def test_Domain__unify():
assert ZZ.unify(ZZ) == ZZ
assert QQ.unify(QQ) == QQ
assert ZZ.unify(QQ) == QQ
assert QQ.unify(ZZ) == QQ
assert EX.unify(EX) == EX
assert ZZ.unify(EX) == EX
assert QQ.unify(EX) == EX
assert EX.unify(ZZ) == EX
assert EX.unify(QQ) == EX
assert ZZ.poly_ring('x').unify(EX) == EX
assert ZZ.frac_field('x').unify(EX) == EX
assert EX.unify(ZZ.poly_ring('x')) == EX
assert EX.unify(ZZ.frac_field('x')) == EX
assert ZZ.poly_ring('x','y').unify(EX) == EX
assert ZZ.frac_field('x','y').unify(EX) == EX
assert EX.unify(ZZ.poly_ring('x','y')) == EX
assert EX.unify(ZZ.frac_field('x','y')) == EX
assert QQ.poly_ring('x').unify(EX) == EX
assert QQ.frac_field('x').unify(EX) == EX
assert EX.unify(QQ.poly_ring('x')) == EX
assert EX.unify(QQ.frac_field('x')) == EX
assert QQ.poly_ring('x','y').unify(EX) == EX
assert QQ.frac_field('x','y').unify(EX) == EX
assert EX.unify(QQ.poly_ring('x','y')) == EX
assert EX.unify(QQ.frac_field('x','y')) == EX
assert ZZ.poly_ring('x').unify(ZZ) == ZZ.poly_ring('x')
assert ZZ.poly_ring('x').unify(QQ) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(ZZ) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(QQ) == QQ.poly_ring('x')
assert ZZ.unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x')
assert QQ.unify(ZZ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.poly_ring('x','y').unify(ZZ) == ZZ.poly_ring('x','y')
assert ZZ.poly_ring('x','y').unify(QQ) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(ZZ) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(QQ) == QQ.poly_ring('x','y')
assert ZZ.unify(ZZ.poly_ring('x','y')) == ZZ.poly_ring('x','y')
assert QQ.unify(ZZ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert ZZ.unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert QQ.unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert ZZ.frac_field('x').unify(ZZ) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ) == QQ.frac_field('x')
assert ZZ.unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert QQ.unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x')
assert ZZ.unify(QQ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x','y').unify(ZZ) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(QQ) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(ZZ) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(QQ) == QQ.frac_field('x','y')
assert ZZ.unify(ZZ.frac_field('x','y')) == ZZ.frac_field('x','y')
assert QQ.unify(ZZ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert ZZ.unify(QQ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert ZZ.poly_ring('x').unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x')
assert ZZ.poly_ring('x').unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(ZZ.poly_ring('x')) == QQ.poly_ring('x')
assert QQ.poly_ring('x').unify(QQ.poly_ring('x')) == QQ.poly_ring('x')
assert ZZ.poly_ring('x','y').unify(ZZ.poly_ring('x')) == ZZ.poly_ring('x','y')
assert ZZ.poly_ring('x','y').unify(QQ.poly_ring('x')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(ZZ.poly_ring('x')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x','y').unify(QQ.poly_ring('x')) == QQ.poly_ring('x','y')
assert ZZ.poly_ring('x').unify(ZZ.poly_ring('x','y')) == ZZ.poly_ring('x','y')
assert ZZ.poly_ring('x').unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x').unify(ZZ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert QQ.poly_ring('x').unify(QQ.poly_ring('x','y')) == QQ.poly_ring('x','y')
assert ZZ.poly_ring('x','y').unify(ZZ.poly_ring('x','z')) == ZZ.poly_ring('x','y','z')
assert ZZ.poly_ring('x','y').unify(QQ.poly_ring('x','z')) == QQ.poly_ring('x','y','z')
assert QQ.poly_ring('x','y').unify(ZZ.poly_ring('x','z')) == QQ.poly_ring('x','y','z')
assert QQ.poly_ring('x','y').unify(QQ.poly_ring('x','z')) == QQ.poly_ring('x','y','z')
assert ZZ.frac_field('x').unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ.frac_field('x')) == QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x','y').unify(ZZ.frac_field('x')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(QQ.frac_field('x')) == QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(ZZ.frac_field('x')) == QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(QQ.frac_field('x')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x').unify(ZZ.frac_field('x','y')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x').unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(ZZ.frac_field('x','y')) == QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(ZZ.frac_field('x','z')) == ZZ.frac_field('x','y','z')
assert ZZ.frac_field('x','y').unify(QQ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(ZZ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(QQ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert ZZ.poly_ring('x').unify(ZZ.frac_field('x')) == ZZ.frac_field('x')
assert ZZ.poly_ring('x').unify(QQ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.poly_ring('x').unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x')
assert QQ.poly_ring('x').unify(QQ.frac_field('x')) == QQ.frac_field('x')
assert ZZ.poly_ring('x','y').unify(ZZ.frac_field('x')) == ZZ.frac_field('x','y')
assert ZZ.poly_ring('x','y').unify(QQ.frac_field('x')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x','y').unify(ZZ.frac_field('x')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x','y').unify(QQ.frac_field('x')) == QQ.frac_field('x','y')
assert ZZ.poly_ring('x').unify(ZZ.frac_field('x','y')) == ZZ.frac_field('x','y')
assert ZZ.poly_ring('x').unify(QQ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x').unify(ZZ.frac_field('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.poly_ring('x').unify(QQ.frac_field('x','y')) == QQ.frac_field('x','y')
assert ZZ.poly_ring('x','y').unify(ZZ.frac_field('x','z')) == ZZ.frac_field('x','y','z')
assert ZZ.poly_ring('x','y').unify(QQ.frac_field('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.poly_ring('x','y').unify(ZZ.frac_field('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.poly_ring('x','y').unify(QQ.frac_field('x','z')) == QQ.frac_field('x','y','z')
assert ZZ.frac_field('x').unify(ZZ.poly_ring('x')) == ZZ.frac_field('x')
assert ZZ.frac_field('x').unify(QQ.poly_ring('x')) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(ZZ.poly_ring('x')) == EX # QQ.frac_field('x')
assert QQ.frac_field('x').unify(QQ.poly_ring('x')) == QQ.frac_field('x')
assert ZZ.frac_field('x','y').unify(ZZ.poly_ring('x')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(QQ.poly_ring('x')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(ZZ.poly_ring('x')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x','y').unify(QQ.poly_ring('x')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x').unify(ZZ.poly_ring('x','y')) == ZZ.frac_field('x','y')
assert ZZ.frac_field('x').unify(QQ.poly_ring('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(ZZ.poly_ring('x','y')) == EX # QQ.frac_field('x','y')
assert QQ.frac_field('x').unify(QQ.poly_ring('x','y')) == QQ.frac_field('x','y')
assert ZZ.frac_field('x','y').unify(ZZ.poly_ring('x','z')) == ZZ.frac_field('x','y','z')
assert ZZ.frac_field('x','y').unify(QQ.poly_ring('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(ZZ.poly_ring('x','z')) == EX # QQ.frac_field('x','y','z')
assert QQ.frac_field('x','y').unify(QQ.poly_ring('x','z')) == QQ.frac_field('x','y','z')
alg = QQ.algebraic_field(sqrt(5))
assert alg.unify(alg['x','y']) == alg['x','y']
assert alg['x','y'].unify(alg) == alg['x','y']
assert alg.unify(alg.frac_field('x','y')) == alg.frac_field('x','y')
assert alg.frac_field('x','y').unify(alg) == alg.frac_field('x','y')
ext = QQ.algebraic_field(sqrt(7))
raises(NotImplementedError, "alg.unify(ext)")
raises(UnificationFailed, "ZZ.poly_ring('x','y').unify(ZZ, gens=('y', 'z'))")
raises(UnificationFailed, "ZZ.unify(ZZ.poly_ring('x','y'), gens=('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___eq__():
assert not QQ['x'] == ZZ['x']
assert not QQ.frac_field(x) == ZZ.frac_field(x)
def test___eq__():
assert not QQ['x'] == ZZ['x']
assert not QQ.frac_field(x) == ZZ.frac_field(x)
def test_issue_14433():
assert (Rational(2, 3) * x in QQ.frac_field(1 / x)) is True
assert (1 / x in QQ.frac_field(x)) is True
assert ((x**2 + y**2) in QQ.frac_field(1 / x, 1 / y)) is True
assert ((x + y) in QQ.frac_field(1 / x, y)) is True
assert ((x - y) in QQ.frac_field(x, 1 / y)) is True
def test_Domain_unify():
F3 = GF(3)
assert unify(F3, F3) == F3
assert unify(F3, ZZ) == ZZ
assert unify(F3, QQ) == QQ
assert unify(F3, ALG) == ALG
assert unify(F3, RR) == RR
assert unify(F3, CC) == CC
assert unify(F3, ZZ[x]) == ZZ[x]
assert unify(F3, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(F3, EX) == EX
assert unify(ZZ, F3) == ZZ
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[x]) == ZZ[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[x]) == QQ[x]
assert unify(QQ, ZZ.frac_field(x)) == QQ.frac_field(x)
assert unify(QQ, EX) == EX
assert unify(ZZ_I, F3) == ZZ_I
assert unify(ZZ_I, ZZ) == ZZ_I
assert unify(ZZ_I, ZZ_I) == ZZ_I
assert unify(ZZ_I, QQ) == QQ_I
assert unify(ZZ_I, ALG) == QQ.algebraic_field(I, sqrt(2), sqrt(3))
assert unify(ZZ_I, RR) == CC
assert unify(ZZ_I, CC) == CC
assert unify(ZZ_I, ZZ[x]) == ZZ_I[x]
assert unify(ZZ_I, ZZ_I[x]) == ZZ_I[x]
assert unify(ZZ_I, ZZ.frac_field(x)) == ZZ_I.frac_field(x)
assert unify(ZZ_I, ZZ_I.frac_field(x)) == ZZ_I.frac_field(x)
assert unify(ZZ_I, EX) == EX
assert unify(QQ_I, F3) == QQ_I
assert unify(QQ_I, ZZ) == QQ_I
assert unify(QQ_I, ZZ_I) == QQ_I
assert unify(QQ_I, QQ) == QQ_I
assert unify(QQ_I, ALG) == QQ.algebraic_field(I, sqrt(2), sqrt(3))
assert unify(QQ_I, RR) == CC
assert unify(QQ_I, CC) == CC
assert unify(QQ_I, ZZ[x]) == QQ_I[x]
assert unify(QQ_I, ZZ_I[x]) == QQ_I[x]
assert unify(QQ_I, QQ[x]) == QQ_I[x]
assert unify(QQ_I, QQ_I[x]) == QQ_I[x]
assert unify(QQ_I, ZZ.frac_field(x)) == QQ_I.frac_field(x)
assert unify(QQ_I, ZZ_I.frac_field(x)) == QQ_I.frac_field(x)
assert unify(QQ_I, QQ.frac_field(x)) == QQ_I.frac_field(x)
assert unify(QQ_I, QQ_I.frac_field(x)) == QQ_I.frac_field(x)
assert unify(QQ_I, 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[x]) == RR[x]
assert unify(RR, ZZ.frac_field(x)) == RR.frac_field(x)
assert unify(RR, EX) == EX
assert RR[x].unify(ZZ.frac_field(y)) == RR.frac_field(x, y)
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[x]) == CC[x]
assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
assert unify(CC, EX) == EX
assert unify(ZZ[x], F3) == ZZ[x]
assert unify(ZZ[x], ZZ) == ZZ[x]
assert unify(ZZ[x], QQ) == QQ[x]
assert unify(ZZ[x], ALG) == ALG[x]
assert unify(ZZ[x], RR) == RR[x]
assert unify(ZZ[x], CC) == CC[x]
assert unify(ZZ[x], ZZ[x]) == ZZ[x]
assert unify(ZZ[x], ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ[x], EX) == EX
assert unify(ZZ.frac_field(x), F3) == ZZ.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[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[x]) == EX
assert unify(EX, ZZ.frac_field(x)) == EX
assert unify(EX, EX) == EX
def test_Domain_unify():
F3 = GF(3)
assert unify(F3, F3) == F3
assert unify(F3, ZZ) == ZZ
assert unify(F3, QQ) == QQ
assert unify(F3, ALG) == ALG
assert unify(F3, RR) == RR
assert unify(F3, CC) == CC
assert unify(F3, ZZ[x]) == ZZ[x]
assert unify(F3, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(F3, EX) == EX
assert unify(ZZ, F3) == ZZ
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[x]) == ZZ[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[x]) == QQ[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[x]) == RR[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[x]) == CC[x]
assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
assert unify(CC, EX) == EX
assert unify(ZZ[x], F3) == ZZ[x]
assert unify(ZZ[x], ZZ) == ZZ[x]
assert unify(ZZ[x], QQ) == QQ[x]
assert unify(ZZ[x], ALG) == ALG[x]
assert unify(ZZ[x], RR) == RR[x]
assert unify(ZZ[x], CC) == CC[x]
assert unify(ZZ[x], ZZ[x]) == ZZ[x]
assert unify(ZZ[x], ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ[x], EX) == EX
assert unify(ZZ.frac_field(x), F3) == ZZ.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[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[x]) == EX
assert unify(EX, ZZ.frac_field(x)) == EX
assert unify(EX, EX) == EX
def test_Domain__unify():
assert ZZ.unify(ZZ) == ZZ
assert QQ.unify(QQ) == QQ
assert ZZ.unify(QQ) == QQ
assert QQ.unify(ZZ) == QQ
assert EX.unify(EX) == EX
assert ZZ.unify(EX) == EX
assert QQ.unify(EX) == EX
assert EX.unify(ZZ) == EX
assert EX.unify(QQ) == EX
assert ZZ.poly_ring(x).unify(EX) == EX
assert ZZ.frac_field(x).unify(EX) == EX
assert EX.unify(ZZ.poly_ring(x)) == EX
assert EX.unify(ZZ.frac_field(x)) == EX
assert ZZ.poly_ring(x, y).unify(EX) == EX
assert ZZ.frac_field(x, y).unify(EX) == EX
assert EX.unify(ZZ.poly_ring(x, y)) == EX
assert EX.unify(ZZ.frac_field(x, y)) == EX
assert QQ.poly_ring(x).unify(EX) == EX
assert QQ.frac_field(x).unify(EX) == EX
assert EX.unify(QQ.poly_ring(x)) == EX
assert EX.unify(QQ.frac_field(x)) == EX
assert QQ.poly_ring(x, y).unify(EX) == EX
assert QQ.frac_field(x, y).unify(EX) == EX
assert EX.unify(QQ.poly_ring(x, y)) == EX
assert EX.unify(QQ.frac_field(x, y)) == EX
assert ZZ.poly_ring(x).unify(ZZ) == ZZ.poly_ring(x)
assert ZZ.poly_ring(x).unify(QQ) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(ZZ) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(QQ) == QQ.poly_ring(x)
assert ZZ.unify(ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert QQ.unify(ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert ZZ.unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert QQ.unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).unify(ZZ) == ZZ.poly_ring(x, y)
assert ZZ.poly_ring(x, y).unify(QQ) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(ZZ) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(QQ) == QQ.poly_ring(x, y)
assert ZZ.unify(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert QQ.unify(ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert ZZ.unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert QQ.unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert ZZ.frac_field(x).unify(ZZ) == ZZ.frac_field(x)
assert ZZ.frac_field(x).unify(QQ) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(ZZ) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(QQ) == QQ.frac_field(x)
assert ZZ.unify(ZZ.frac_field(x)) == ZZ.frac_field(x)
assert QQ.unify(ZZ.frac_field(x)) == EX # QQ.frac_field(x)
assert ZZ.unify(QQ.frac_field(x)) == EX # QQ.frac_field(x)
assert QQ.unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert ZZ.frac_field(x, y).unify(ZZ) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(QQ) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(ZZ) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(QQ) == QQ.frac_field(x, y)
assert ZZ.unify(ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert QQ.unify(ZZ.frac_field(x, y)) == EX # QQ.frac_field(x,y)
assert ZZ.unify(QQ.frac_field(x, y)) == EX # QQ.frac_field(x,y)
assert QQ.unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert ZZ.poly_ring(x).unify(ZZ.poly_ring(x)) == ZZ.poly_ring(x)
assert ZZ.poly_ring(x).unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(ZZ.poly_ring(x)) == QQ.poly_ring(x)
assert QQ.poly_ring(x).unify(QQ.poly_ring(x)) == QQ.poly_ring(x)
assert ZZ.poly_ring(x, y).unify(ZZ.poly_ring(x)) == ZZ.poly_ring(x, y)
assert ZZ.poly_ring(x, y).unify(QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(ZZ.poly_ring(x)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x, y).unify(QQ.poly_ring(x)) == QQ.poly_ring(x, y)
assert ZZ.poly_ring(x).unify(ZZ.poly_ring(x, y)) == ZZ.poly_ring(x, y)
assert ZZ.poly_ring(x).unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x).unify(ZZ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert QQ.poly_ring(x).unify(QQ.poly_ring(x, y)) == QQ.poly_ring(x, y)
assert ZZ.poly_ring(x, y).unify(ZZ.poly_ring(x,
z)) == ZZ.poly_ring(x, y, z)
assert ZZ.poly_ring(x, y).unify(QQ.poly_ring(x,
z)) == QQ.poly_ring(x, y, z)
assert QQ.poly_ring(x, y).unify(ZZ.poly_ring(x,
z)) == QQ.poly_ring(x, y, z)
assert QQ.poly_ring(x, y).unify(QQ.poly_ring(x,
z)) == QQ.poly_ring(x, y, z)
assert ZZ.frac_field(x).unify(ZZ.frac_field(x)) == ZZ.frac_field(x)
assert ZZ.frac_field(x).unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert QQ.frac_field(x).unify(ZZ.frac_field(x)) == QQ.frac_field(x)
assert QQ.frac_field(x).unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert ZZ.frac_field(x, y).unify(ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(QQ.frac_field(x)) == QQ.frac_field(x, y)
assert QQ.frac_field(x, y).unify(ZZ.frac_field(x)) == QQ.frac_field(x, y)
assert QQ.frac_field(x, y).unify(QQ.frac_field(x)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x).unify(ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x).unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert QQ.frac_field(x).unify(ZZ.frac_field(x, y)) == QQ.frac_field(x, y)
assert QQ.frac_field(x).unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x,
y).unify(ZZ.frac_field(x,
z)) == ZZ.frac_field(x, y, z)
assert ZZ.frac_field(x,
y).unify(QQ.frac_field(x,
z)) == QQ.frac_field(x, y, z)
assert QQ.frac_field(x,
y).unify(ZZ.frac_field(x,
z)) == QQ.frac_field(x, y, z)
assert QQ.frac_field(x,
y).unify(QQ.frac_field(x,
z)) == QQ.frac_field(x, y, z)
assert ZZ.poly_ring(x).unify(ZZ.frac_field(x)) == ZZ.frac_field(x)
assert ZZ.poly_ring(x).unify(QQ.frac_field(x)) == EX # QQ.frac_field(x)
assert QQ.poly_ring(x).unify(ZZ.frac_field(x)) == EX # QQ.frac_field(x)
assert QQ.poly_ring(x).unify(QQ.frac_field(x)) == QQ.frac_field(x)
assert ZZ.poly_ring(x, y).unify(ZZ.frac_field(x)) == ZZ.frac_field(x, y)
assert ZZ.poly_ring(x, y).unify(
QQ.frac_field(x)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x, y).unify(
ZZ.frac_field(x)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x, y).unify(QQ.frac_field(x)) == QQ.frac_field(x, y)
assert ZZ.poly_ring(x).unify(ZZ.frac_field(x, y)) == ZZ.frac_field(x, y)
assert ZZ.poly_ring(x).unify(QQ.frac_field(x,
y)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x).unify(ZZ.frac_field(x,
y)) == EX # QQ.frac_field(x,y)
assert QQ.poly_ring(x).unify(QQ.frac_field(x, y)) == QQ.frac_field(x, y)
assert ZZ.poly_ring(x,
y).unify(ZZ.frac_field(x,
z)) == ZZ.frac_field(x, y, z)
assert ZZ.poly_ring(x, y).unify(QQ.frac_field(
x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.poly_ring(x, y).unify(ZZ.frac_field(
x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.poly_ring(x,
y).unify(QQ.frac_field(x,
z)) == QQ.frac_field(x, y, z)
assert ZZ.frac_field(x).unify(ZZ.poly_ring(x)) == ZZ.frac_field(x)
assert ZZ.frac_field(x).unify(QQ.poly_ring(x)) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(ZZ.poly_ring(x)) == EX # QQ.frac_field(x)
assert QQ.frac_field(x).unify(QQ.poly_ring(x)) == QQ.frac_field(x)
assert ZZ.frac_field(x, y).unify(ZZ.poly_ring(x)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x, y).unify(
QQ.poly_ring(x)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(
ZZ.poly_ring(x)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x, y).unify(QQ.poly_ring(x)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x).unify(ZZ.poly_ring(x, y)) == ZZ.frac_field(x, y)
assert ZZ.frac_field(x).unify(QQ.poly_ring(x,
y)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x).unify(ZZ.poly_ring(x,
y)) == EX # QQ.frac_field(x,y)
assert QQ.frac_field(x).unify(QQ.poly_ring(x, y)) == QQ.frac_field(x, y)
assert ZZ.frac_field(x,
y).unify(ZZ.poly_ring(x,
z)) == ZZ.frac_field(x, y, z)
assert ZZ.frac_field(x, y).unify(QQ.poly_ring(
x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.frac_field(x, y).unify(ZZ.poly_ring(
x, z)) == EX # QQ.frac_field(x,y,z)
assert QQ.frac_field(x,
y).unify(QQ.poly_ring(x,
z)) == QQ.frac_field(x, y, z)
alg = QQ.algebraic_field(sqrt(5))
assert alg.unify(alg[x, y]) == alg[x, y]
assert alg[x, y].unify(alg) == alg[x, y]
assert alg.unify(alg.frac_field(x, y)) == alg.frac_field(x, y)
assert alg.frac_field(x, y).unify(alg) == alg.frac_field(x, y)
ext = QQ.algebraic_field(sqrt(7))
raises(NotImplementedError, lambda: alg.unify(ext))
raises(UnificationFailed,
lambda: ZZ.poly_ring(x, y).unify(ZZ, gens=(y, z)))
raises(UnificationFailed,
lambda: ZZ.unify(ZZ.poly_ring(x, y), gens=(y, z)))
def test_Domain_unify():
F3 = GF(3)
assert unify(F3, F3) == F3
assert unify(F3, ZZ) == ZZ
assert unify(F3, QQ) == QQ
assert unify(F3, ALG) == ALG
assert unify(F3, RR) == RR
assert unify(F3, CC) == CC
assert unify(F3, ZZ[x]) == ZZ[x]
assert unify(F3, ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(F3, EX) == EX
assert unify(ZZ, F3) == ZZ
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[x]) == ZZ[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[x]) == QQ[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[x]) == RR[x]
assert unify(RR, ZZ.frac_field(x)) == RR.frac_field(x)
assert unify(RR, EX) == EX
assert RR[x].unify(ZZ.frac_field(y)) == RR.frac_field(x, y)
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[x]) == CC[x]
assert unify(CC, ZZ.frac_field(x)) == CC.frac_field(x)
assert unify(CC, EX) == EX
assert unify(ZZ[x], F3) == ZZ[x]
assert unify(ZZ[x], ZZ) == ZZ[x]
assert unify(ZZ[x], QQ) == QQ[x]
assert unify(ZZ[x], ALG) == ALG[x]
assert unify(ZZ[x], RR) == RR[x]
assert unify(ZZ[x], CC) == CC[x]
assert unify(ZZ[x], ZZ[x]) == ZZ[x]
assert unify(ZZ[x], ZZ.frac_field(x)) == ZZ.frac_field(x)
assert unify(ZZ[x], EX) == EX
assert unify(ZZ.frac_field(x), F3) == ZZ.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[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[x]) == EX
assert unify(EX, ZZ.frac_field(x)) == EX
assert unify(EX, EX) == EX
