def test_Domain_field():
assert EX.field == EX
assert ZZ.field == QQ
assert QQ.field == QQ
assert RR.field == RR
assert ALG.field == ALG
assert ZZ.inject(x).field == ZZ.frac_field(x)
assert QQ.inject(x).field == QQ.frac_field(x)
assert ZZ.inject(x, y).field == ZZ.frac_field(x, y)
assert QQ.inject(x, y).field == QQ.frac_field(x, y)
def test_PolynomialRing():
sT(ZZ.inject('x'),
f"UnivarPolynomialRing({ZZ!r}, (Symbol('x'),), LexOrder())")
sT(
QQ.poly_ring('x', 'y', order=grlex),
f"PolynomialRing({QQ!r}, (Symbol('x'), Symbol('y')), GradedLexOrder())"
)
sT(
ZZ.inject('x', 'y', 'z', 't').eject('t'),
f"PolynomialRing(UnivarPolynomialRing({ZZ!r}, (Symbol('t'),), "
"LexOrder()), (Symbol('x'), Symbol('y'), Symbol('z')), LexOrder())")
def test_FractionField___init__():
F1 = ZZ.inject('x', 'y').field
F2 = ZZ.inject('x', 'y').field
F3 = ZZ.inject('x', 'y', 'z').field
assert F1.x == F1.gens[0]
assert F1.y == F1.gens[1]
assert F1.x == F2.x
assert F1.y == F2.y
assert F1.x != F3.x
assert F1.y != F3.y
F4 = ZZ.inject('gens').field
assert type(F4.gens) is tuple
def test_FractionField_methods():
F = ZZ.inject('x').field
assert F.domain_new(2) == ZZ(2)
x = symbols('x')
assert F(x**2 + x) == F.x**2 + F.x
def test_Domain_postprocess():
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'gens': (x, y),
'domain': ZZ.inject(y, z)}))
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'gens': (),
'domain': EX}))
pytest.raises(GeneratorsError, lambda: Domain.postprocess({'domain': EX}))
def test_localring():
Qxy = QQ.inject(x, y).field
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.inject(x, y).convert(x), ZZ.inject(x, y)) == X
assert R.convert(Qxy.convert(x), Qxy) == X
def test_sympyissue_21460():
R = ZZ.inject('x')
r = R.gcd(R(4), R(6))
assert type(r) is R.dtype and r == 2
R = QQ.inject('x')
r = R.gcd(R(4), R(6))
assert type(r) is R.dtype and r == 1
def test_Domain___eq__():
assert (ZZ.inject(x, y) == ZZ.inject(x, y)) is True
assert (QQ.inject(x, y) == QQ.inject(x, y)) is True
assert (ZZ.inject(x, y) == QQ.inject(x, y)) is False
assert (QQ.inject(x, y) == ZZ.inject(x, y)) is False
assert (ZZ.inject(x, y).field == ZZ.inject(x, y).field) is True
assert (QQ.inject(x, y).field == QQ.inject(x, y).field) is True
assert (ZZ.inject(x, y).field == QQ.inject(x, y).field) is False
assert (QQ.inject(x, y).field == ZZ.inject(x, y).field) is False
def test_globalring():
Qxy = QQ.inject(x, y).field
R = QQ.inject(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.inject(x, y).convert(x), ZZ.inject(x, y)) == X
assert R.convert(Qxy.convert(x), Qxy) == X
def test__dict_from_expr_no_gens():
pytest.raises(GeneratorsNeeded,
lambda: parallel_dict_from_expr([Integer(17)]))
assert parallel_dict_from_expr([x]) == ([{(1, ): 1}], (x, ))
assert parallel_dict_from_expr([y]) == ([{(1, ): 1}], (y, ))
assert parallel_dict_from_expr([x * y]) == ([{(1, 1): 1}], (x, y))
assert parallel_dict_from_expr([x + y]) == ([{
(1, 0): 1,
(0, 1): 1
}], (x, y))
assert parallel_dict_from_expr([sqrt(2)]) == ([{(1, ): 1}], (sqrt(2), ))
pytest.raises(GeneratorsNeeded,
lambda: parallel_dict_from_expr([sqrt(2)], greedy=False))
assert parallel_dict_from_expr([x * y], domain=ZZ.inject(x)) == ([{
(1, ): x
}], (y, ))
assert parallel_dict_from_expr([x * y], domain=ZZ.inject(y)) == ([{
(1, ): y
}], (x, ))
assert parallel_dict_from_expr([3 * sqrt(2) * pi * x * y],
extension=None) == ([{
(1, 1, 1, 1): 3
}], (x, y, pi, sqrt(2)))
assert parallel_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 parallel_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_FracElement___call__():
_, x, y, z = field('x y z', ZZ)
f = (x**2 + 3 * y) / z
pytest.raises(ValueError, lambda: f(1, 1, 1, 1))
r = f(1, 1, 1)
assert r == 4 and not isinstance(r, FracElement)
pytest.raises(ZeroDivisionError, lambda: f(1, 1, 0))
Fz = ZZ.inject('z').field
assert f(1, 1) == 4 / Fz.z
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.inject(x).get_exact() == ZZ.inject(x)
assert QQ.inject(x).get_exact() == QQ.inject(x)
assert ZZ.inject(x, y).get_exact() == ZZ.inject(x, y)
assert QQ.inject(x, y).get_exact() == QQ.inject(x, y)
assert ZZ.inject(x).field.get_exact() == ZZ.inject(x).field
assert QQ.inject(x).field.get_exact() == QQ.inject(x).field
assert ZZ.inject(x, y).field.get_exact() == ZZ.inject(x, y).field
assert QQ.inject(x, y).field.get_exact() == QQ.inject(x, y).field
def test_dmp_convert():
K0, K1 = ZZ.inject('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_apart_undetermined_coeffs():
p = (2 * x - 3).as_poly()
q = (x**9 - x**8 - x**6 + x**5 - 2 * x**2 + 3 * x - 1).as_poly()
r = (-x**7 - x**6 - x**5 + 4) / (x**8 - x**5 - 2 * x + 1) + 1 / (x - 1)
assert apart_undetermined_coeffs(p, q) == r
dom = ZZ.inject(a, b)
p = Integer(1).as_poly(x, domain=dom)
q = ((x + a) * (x + b)).as_poly(x, domain=dom)
r = 1 / ((a - b) * (b + x)) - 1 / ((a - b) * (a + x))
assert apart_undetermined_coeffs(p, q) == r
def test_units():
R = QQ.inject(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.inject(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_gegenbauer_poly():
pytest.raises(ValueError, lambda: gegenbauer_poly(-1, a, x))
dom = ZZ.inject(a).field
assert gegenbauer_poly(1, a, x,
polys=True) == (2 * a * x).as_poly(x, domain=dom)
assert gegenbauer_poly(0, a, x) == 1
assert gegenbauer_poly(1, a, x) == 2 * a * x
assert gegenbauer_poly(2, a, x) == -a + x**2 * (2 * a**2 + 2 * a)
assert gegenbauer_poly(
3, a, x
) == x**3 * (4 * a**3 / 3 + 4 * a**2 + 8 * a / 3) + x * (-2 * a**2 - 2 * a)
assert gegenbauer_poly(1, Rational(1, 2), x) == x
assert gegenbauer_poly(1, a, polys=True) == (2 * a * x).as_poly(x,
domain=dom)
def test_jacobi_poly():
pytest.raises(ValueError, lambda: jacobi_poly(-1, a, b, x))
dom = ZZ.inject(a, b).field
assert (jacobi_poly(1, a, b, x,
polys=True) == ((a / 2 + b / 2 + 1) * x + a / 2 -
b / 2).as_poly(x, domain=dom))
assert jacobi_poly(0, a, b, x) == 1
assert jacobi_poly(1, a, b, x) == a / 2 - b / 2 + x * (a / 2 + b / 2 + 1)
assert jacobi_poly(
2, a, b,
x) == (a**2 / 8 - a * b / 4 - a / 8 + b**2 / 8 - b / 8 + x**2 *
(a**2 / 8 + a * b / 4 + 7 * a / 8 + b**2 / 8 + 7 * b / 8 +
Rational(3, 2)) + x *
(a**2 / 4 + 3 * a / 4 - b**2 / 4 - 3 * b / 4) - Rational(1, 2))
assert (jacobi_poly(1, a, b,
polys=True) == ((a / 2 + b / 2 + 1) * x + a / 2 -
b / 2).as_poly(x, domain=dom))
def test__cyclotomic_p():
R, x = ring('x', ZZ)
assert (x - 1).is_cyclotomic is True
assert (x + 1).is_cyclotomic is True
assert (x**2 + x + 1).is_cyclotomic is True
f = x**2 + 1
assert f.is_cyclotomic is True
assert R._cyclotomic_p(f, irreducible=True) is True
assert (x**4 + x**3 + x**2 + x + 1).is_cyclotomic is True
assert (x**2 - x + 1).is_cyclotomic is True
assert (x**6 + x**5 + x**4 + x**3 + x**2 + x + 1).is_cyclotomic is True
assert (x**4 + 1).is_cyclotomic is True
assert (x**6 + x**3 + 1).is_cyclotomic is True
assert R(0).is_cyclotomic is False
assert R(1).is_cyclotomic is False
assert x.is_cyclotomic is False
assert (x + 2).is_cyclotomic is False
assert (3 * x + 1).is_cyclotomic is False
assert (x**2 - 1).is_cyclotomic is False
f = x**16 + x**14 - x**10 - x**6 + x**2 + 1
assert (f + x**8).is_cyclotomic is False
assert (f - x**8).is_cyclotomic is True
R, x = ring('x', QQ)
assert (x**2 + x + 1).is_cyclotomic is True
assert (x**2 / 2 + x + 1).is_cyclotomic is False
R, x = ring('x', ZZ.inject('y'))
assert (x**2 + x + 1).is_cyclotomic is False
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.inject(x, y)) is True
assert (0 in QQ.inject(x, y)) is True
assert (0 in RR.inject(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.inject(x, y)) is True
assert (-7 in QQ.inject(x, y)) is True
assert (-7 in RR.inject(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.inject(x, y)) is True
assert (17 in QQ.inject(x, y)) is True
assert (17 in RR.inject(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.inject(x, y)) is False
assert (-Rational(1, 7) in QQ.inject(x, y)) is True
assert (-Rational(1, 7) in RR.inject(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.inject(x, y)) is False
assert (Rational(3, 5) in QQ.inject(x, y)) is True
assert (Rational(3, 5) in RR.inject(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.inject(x, y)) is True
assert (3.0 in QQ.inject(x, y)) is True
assert (3.0 in RR.inject(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.inject(x, y)) is False
assert (3.14 in QQ.inject(x, y)) is True
assert (3.14 in RR.inject(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.inject(x, y)) is False
assert (oo in QQ.inject(x, y)) is False
assert (oo in RR.inject(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.inject(x, y)) is False
assert (-oo in QQ.inject(x, y)) is False
assert (-oo in RR.inject(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.inject(x, y)) is False
assert (sqrt(7) in QQ.inject(x, y)) is False
assert (sqrt(7) in RR.inject(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.inject(x, y)) is False
assert (2 * sqrt(3) + 1 in QQ.inject(x, y)) is False
assert (2 * sqrt(3) + 1 in RR.inject(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.inject(x, y)) is False
assert (sin(1) in QQ.inject(x, y)) is False
assert (sin(1) in RR.inject(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.inject(x)) is True
assert (x**2 + 1 in QQ.inject(x)) is True
assert (x**2 + 1 in RR.inject(x)) is True
assert (x**2 + 1 in ZZ.inject(x, y)) is True
assert (x**2 + 1 in QQ.inject(x, y)) is True
assert (x**2 + 1 in RR.inject(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.inject(x)) is False
assert (x**2 + y**2 in QQ.inject(x)) is False
assert (x**2 + y**2 in RR.inject(x)) is False
assert (x**2 + y**2 in ZZ.inject(x, y)) is True
assert (x**2 + y**2 in QQ.inject(x, y)) is True
assert (x**2 + y**2 in RR.inject(x, y)) is True
assert (Rational(3, 2) * x / (y + 1) - z in QQ.inject(x, y, z)) is False
R = QQ.inject(x)
assert R(1) in ZZ
F = R.field
assert F(1) in ZZ
def test_Domain_ring():
assert ZZ.has_assoc_Ring is True
assert QQ.has_assoc_Ring is True
assert ZZ.inject(x).has_assoc_Ring is True
assert QQ.inject(x).has_assoc_Ring is True
assert ZZ.inject(x, y).has_assoc_Ring is True
assert QQ.inject(x, y).has_assoc_Ring is True
assert ZZ.inject(x).field.has_assoc_Ring is True
assert QQ.inject(x).field.has_assoc_Ring is True
assert ZZ.inject(x, y).field.has_assoc_Ring is True
assert QQ.inject(x, y).field.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.inject(x).ring == ZZ.inject(x)
assert QQ.inject(x).ring == QQ.inject(x)
assert ZZ.inject(x, y).ring == ZZ.inject(x, y)
assert QQ.inject(x, y).ring == QQ.inject(x, y)
assert ZZ.inject(x).field.ring == ZZ.inject(x)
assert QQ.inject(x).field.ring == QQ.inject(x)
assert ZZ.inject(x, y).field.ring == ZZ.inject(x, y)
assert QQ.inject(x, y).field.ring == QQ.inject(x, y)
assert EX.ring == EX
pytest.raises(AttributeError, lambda: RR.ring)
pytest.raises(NotImplementedError, lambda: ALG.ring)
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.inject(x)) == F3.inject(x)
assert unify(F3, ZZ.inject(x).field) == F3.inject(x).field
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.inject(x)) == ZZ.inject(x)
assert unify(ZZ, ZZ.inject(x).field) == ZZ.inject(x).field
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.inject(x)) == QQ.inject(x)
assert unify(QQ, ZZ.inject(x).field) == QQ.inject(x).field
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.inject(x)) == RR.inject(x)
assert unify(RR, ZZ.inject(x).field) == RR.inject(x).field
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.inject(x)) == CC.inject(x)
assert unify(CC, ZZ.inject(x).field) == CC.inject(x).field
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.inject(x), F3) == F3.inject(x)
assert unify(ZZ.inject(x), ZZ) == ZZ.inject(x)
assert unify(ZZ.inject(x), QQ) == QQ.inject(x)
assert unify(ZZ.inject(x), ALG) == ALG.inject(x)
assert unify(ZZ.inject(x), RR) == RR.inject(x)
assert unify(ZZ.inject(x), CC) == CC.inject(x)
assert unify(ZZ.inject(x), ZZ.inject(x)) == ZZ.inject(x)
assert unify(ZZ.inject(x), ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(ZZ.inject(x), EX) == EX
assert unify(ZZ.inject(x).field, F3) == F3.inject(x).field
assert unify(ZZ.inject(x).field, ZZ) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, QQ) == QQ.inject(x).field
assert unify(ZZ.inject(x).field, ALG) == ALG.inject(x).field
assert unify(ZZ.inject(x).field, RR) == RR.inject(x).field
assert unify(ZZ.inject(x).field, CC) == CC.inject(x).field
assert unify(ZZ.inject(x).field, ZZ.inject(x)) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, ZZ.inject(x).field) == ZZ.inject(x).field
assert unify(ZZ.inject(x).field, 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.inject(x)) == EX
assert unify(EX, ZZ.inject(x).field) == EX
assert unify(EX, EX) == EX
def test_PolynomialRing__init():
pytest.raises(GeneratorsNeeded, lambda: ZZ.inject())
def test_FractionField__init():
pytest.raises(GeneratorsNeeded, lambda: ZZ.inject().field)
def test_roots_preprocessing():
f = a * y * x**2 + y - b
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 1
assert poly == Poly(a * y * x**2 + y - b, x)
f = c**3 * x**3 + c**2 * x**2 + c * x + a
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 1 / c
assert poly == Poly(x**3 + x**2 + x + a, x)
f = c**3 * x**3 + c**2 * x**2 + a
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 1 / c
assert poly == Poly(x**3 + x**2 + a, x)
f = c**3 * x**3 + c * x + a
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 1 / c
assert poly == Poly(x**3 + x + a, x)
f = c**3 * x**3 + a
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 1 / c
assert poly == Poly(x**3 + a, x)
E, F, J, L = symbols('E,F,J,L')
f = -21601054687500000000*E**8*J**8/L**16 + \
508232812500000000*F*x*E**7*J**7/L**14 - \
4269543750000000*E**6*F**2*J**6*x**2/L**12 + \
16194716250000*E**5*F**3*J**5*x**3/L**10 - \
27633173750*E**4*F**4*J**4*x**4/L**8 + \
14840215*E**3*F**5*J**3*x**5/L**6 + \
54794*E**2*F**6*J**2*x**6/(5*L**4) - \
1153*E*J*F**7*x**7/(80*L**2) + \
633*F**8*x**8/160000
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 20 * E * J / (F * L**2)
assert poly == 633*x**8 - 115300*x**7 + 4383520*x**6 + 296804300*x**5 - 27633173750*x**4 + \
809735812500*x**3 - 10673859375000*x**2 + 63529101562500*x - 135006591796875
f = J**8 + 7 * E * x**2 * L**16 + 5 * F * x * E**5 * J**7 * L**2
coeff, poly = preprocess_roots(Poly(f, x))
assert coeff == 1
assert poly == Poly(f, x)
f = Poly(-y**2 + x**2 * exp(x), y, domain=ZZ.inject(x, exp(x)))
g = Poly(y**2 - exp(x), y, domain=ZZ.inject(exp(x)))
assert preprocess_roots(f) == (x, g)
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.inject(x, y)) == ZZ.inject(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.inject(x)
assert Domain.preprocess('Q[x]') == QQ.inject(x)
assert Domain.preprocess('ZZ[x]') == ZZ.inject(x)
assert Domain.preprocess('QQ[x]') == QQ.inject(x)
assert Domain.preprocess('Z[x,y]') == ZZ.inject(x, y)
assert Domain.preprocess('Q[x,y]') == QQ.inject(x, y)
assert Domain.preprocess('ZZ[x,y]') == ZZ.inject(x, y)
assert Domain.preprocess('QQ[x,y]') == QQ.inject(x, y)
pytest.raises(OptionError, lambda: Domain.preprocess('Z()'))
assert Domain.preprocess('Z(x)') == ZZ.inject(x).field
assert Domain.preprocess('Q(x)') == QQ.inject(x).field
assert Domain.preprocess('ZZ(x)') == ZZ.inject(x).field
assert Domain.preprocess('QQ(x)') == QQ.inject(x).field
assert Domain.preprocess('Z(x,y)') == ZZ.inject(x, y).field
assert Domain.preprocess('Q(x,y)') == QQ.inject(x, y).field
assert Domain.preprocess('ZZ(x,y)') == ZZ.inject(x, y).field
assert Domain.preprocess('QQ(x,y)') == QQ.inject(x, y).field
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).inject(y, z) == ZZ.inject(x, y, z)
assert ZZ.inject(x).inject(y, z, front=True) == ZZ.inject(y, z, x)
assert ZZ.inject(x).field.inject(y, z) == ZZ.inject(x, y, z).field
pytest.raises(GeneratorsError, lambda: ZZ.inject(x).inject(x))
def test_PolynomialRing():
assert str(ZZ.inject('x')) == 'ZZ[x]'
assert str(QQ.poly_ring('x', 'y', order=grlex)) == 'QQ[x,y]'
assert str(ZZ.inject('x', 'y', 'z', 't').eject('t')) == 'ZZ[t][x,y,z]'
def test_FractionField():
assert str(ZZ.inject('x').field) == 'ZZ(x)'
assert str(QQ.frac_field('x', 'y', order=grlex)) == 'QQ(x,y)'
assert str(ZZ.inject('x', 'y', 'z',
't').eject('t').field) == 'ZZ[t](x,y,z)'
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=False) == (EX, [EX(3.14),
EX(sqrt(2))])
assert construct_domain([3.14, sqrt(2)]) == (EX, [EX(3.14), EX(sqrt(2))])
assert construct_domain([sqrt(2), 3.14]) == (EX, [EX(sqrt(2)), EX(3.14)])
assert construct_domain([1, sqrt(2)],
extension=False) == (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)]) == (alg, [alg([7]),
alg([Rational(1, 2)]),
alg([1, 0])]))
alg = QQ.algebraic_field(sqrt(2) + sqrt(3))
assert (construct_domain([7, sqrt(2), sqrt(3)]) == (alg, [
alg([7]), alg.from_expr(sqrt(2)),
alg.from_expr(sqrt(3))
]))
dom = ZZ.inject(x)
assert construct_domain([2 * x, 3]) == (dom, [dom(2 * x), dom(3)])
dom = ZZ.inject(x, y)
assert construct_domain([2 * x, 3 * y]) == (dom, [dom(2 * x), dom(3 * y)])
dom = QQ.inject(x)
assert construct_domain([x / 2, 3]) == (dom, [dom(x / 2), dom(3)])
dom = QQ.inject(x, y)
assert construct_domain([x / 2, 3 * y]) == (dom, [dom(x / 2), dom(3 * y)])
dom = RR.inject(x)
assert construct_domain([x / 2, 3.5]) == (dom, [dom(x / 2), dom(3.5)])
dom = RR.inject(x, y)
assert construct_domain([x / 2,
3.5 * y]) == (dom, [dom(x / 2),
dom(3.5 * y)])
dom = ZZ.inject(x).field
assert construct_domain([2 / x, 3]) == (dom, [dom(2 / x), dom(3)])
dom = ZZ.inject(x, y).field
assert construct_domain([2 / x, 3 * y]) == (dom, [dom(2 / x), dom(3 * y)])
dom = RR.inject(x).field
assert construct_domain([2 / x, 3.5]) == (dom, [dom(2 / x), dom(3.5)])
dom = RR.inject(x, y).field
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, {})
assert construct_domain([-x * y + x * (y + 42) - 42 * x
]) == (EX, [EX(-x * y + x * (y + 42) - 42 * x)])
def test_sympyissue_11538():
assert construct_domain(E)[0] == ZZ.inject(E)
assert (construct_domain(x**2 + 2 * x + E) == (ZZ.inject(
x, E), ZZ.inject(x, E)(x**2 + 2 * x + E)))
assert (construct_domain(x + y + GoldenRatio) == (EX,
EX(x + y + GoldenRatio)))