def test__unify_gens():
assert _unify_gens([], []) == ()
assert _unify_gens([x], [x]) == (x,)
assert _unify_gens([y], [y]) == (y,)
assert _unify_gens([x, y], [x]) == (x, y)
assert _unify_gens([x], [x, y]) == (x, y)
assert _unify_gens([x, y], [x, y]) == (x, y)
assert _unify_gens([y, x], [y, x]) == (y, x)
assert _unify_gens([x], [y]) == (x, y)
assert _unify_gens([y], [x]) == (y, x)
assert _unify_gens([x], [y, x]) == (y, x)
assert _unify_gens([y, x], [x]) == (y, x)
assert _unify_gens([x, y, z], [x, y, z]) == (x, y, z)
assert _unify_gens([z, y, x], [x, y, z]) == (z, y, x)
assert _unify_gens([x, y, z], [z, y, x]) == (x, y, z)
assert _unify_gens([z, y, x], [z, y, x]) == (z, y, x)
assert _unify_gens([x, y, z], [t, x, p, q, z]) == (t, x, y, p, q, z)
def test__unify_gens():
assert _unify_gens([], []) == ()
assert _unify_gens([x], [x]) == (x, )
assert _unify_gens([y], [y]) == (y, )
assert _unify_gens([x, y], [x]) == (x, y)
assert _unify_gens([x], [x, y]) == (x, y)
assert _unify_gens([x, y], [x, y]) == (x, y)
assert _unify_gens([y, x], [y, x]) == (y, x)
assert _unify_gens([x], [y]) == (x, y)
assert _unify_gens([y], [x]) == (y, x)
assert _unify_gens([x], [y, x]) == (y, x)
assert _unify_gens([y, x], [x]) == (y, x)
assert _unify_gens([x, y, z], [x, y, z]) == (x, y, z)
assert _unify_gens([z, y, x], [x, y, z]) == (z, y, x)
assert _unify_gens([x, y, z], [z, y, x]) == (x, y, z)
assert _unify_gens([z, y, x], [z, y, x]) == (z, y, x)
assert _unify_gens([x, y, z], [t, x, p, q, z]) == (t, x, y, p, q, z)
def unify(self, K1, symbols=None):
"""
Construct a minimal domain that contains elements of ``self`` and ``K1``.
Known domains (from smallest to largest):
- ``GF(p)``
- ``ZZ``
- ``QQ``
- ``RR(prec, tol)``
- ``CC(prec, tol)``
- ``ALG(a, b, c)``
- ``K[x, y, z]``
- ``K(x, y, z)``
- ``EX``
"""
if symbols is not None:
return self.unify_with_symbols(K1, symbols)
if self == K1:
return self
if self.is_EX:
return self
if K1.is_EX:
return K1
if self.is_Composite or K1.is_Composite:
self_ground = self.domain if self.is_Composite else self
K1_ground = K1.domain if K1.is_Composite else K1
self_symbols = self.symbols if self.is_Composite else ()
K1_symbols = K1.symbols if K1.is_Composite else ()
domain = self_ground.unify(K1_ground)
symbols = _unify_gens(self_symbols, K1_symbols)
order = self.order if self.is_Composite else K1.order
if ((self.is_FractionField and K1.is_PolynomialRing
or K1.is_FractionField and self.is_PolynomialRing)
and (not self_ground.has_Field or not K1_ground.has_Field)
and domain.has_Field):
domain = domain.get_ring()
if self.is_Composite and (not K1.is_Composite
or self.is_FractionField
or K1.is_PolynomialRing):
cls = self.__class__
else:
cls = K1.__class__
return cls(domain, symbols, order)
def mkinexact(cls, K0, K1):
prec = max(K0.precision, K1.precision)
tol = max(K0.tolerance, K1.tolerance)
return cls(prec=prec, tol=tol)
if self.is_ComplexField and K1.is_ComplexField:
return mkinexact(self.__class__, self, K1)
if self.is_ComplexField and K1.is_RealField:
return mkinexact(self.__class__, self, K1)
if self.is_RealField and K1.is_ComplexField:
return mkinexact(K1.__class__, K1, self)
if self.is_RealField and K1.is_RealField:
return mkinexact(self.__class__, self, K1)
if self.is_ComplexField or self.is_RealField:
return self
if K1.is_ComplexField or K1.is_RealField:
return K1
if self.is_AlgebraicField and K1.is_AlgebraicField:
return self.__class__(self.domain.unify(K1.domain),
*_unify_gens(self.orig_ext, K1.orig_ext))
elif self.is_AlgebraicField:
return self
elif K1.is_AlgebraicField:
return K1
if self.is_RationalField:
return self
if K1.is_RationalField:
return K1
if self.is_IntegerRing:
return self
if K1.is_IntegerRing:
return K1
if self.is_FiniteField and K1.is_FiniteField:
return self.__class__(max(self.mod, K1.mod, key=default_sort_key))
from diofant.polys.domains import EX
return EX