209 lines
7.5 KiB
Python
209 lines
7.5 KiB
Python
"""Tests for sparse distributed modules. """
|
|
|
|
from sympy.polys.distributedmodules import (
|
|
sdm_monomial_mul, sdm_monomial_deg, sdm_monomial_divides,
|
|
sdm_add, sdm_LM, sdm_LT, sdm_mul_term, sdm_zero, sdm_deg,
|
|
sdm_LC, sdm_from_dict,
|
|
sdm_spoly, sdm_ecart, sdm_nf_mora, sdm_groebner,
|
|
sdm_from_vector, sdm_to_vector, sdm_monomial_lcm
|
|
)
|
|
|
|
from sympy.polys.orderings import lex, grlex, InverseOrder
|
|
from sympy.polys.domains import QQ
|
|
|
|
from sympy.abc import x, y, z
|
|
|
|
|
|
def test_sdm_monomial_mul():
|
|
assert sdm_monomial_mul((1, 1, 0), (1, 3)) == (1, 2, 3)
|
|
|
|
|
|
def test_sdm_monomial_deg():
|
|
assert sdm_monomial_deg((5, 2, 1)) == 3
|
|
|
|
|
|
def test_sdm_monomial_lcm():
|
|
assert sdm_monomial_lcm((1, 2, 3), (1, 5, 0)) == (1, 5, 3)
|
|
|
|
|
|
def test_sdm_monomial_divides():
|
|
assert sdm_monomial_divides((1, 0, 0), (1, 0, 0)) is True
|
|
assert sdm_monomial_divides((1, 0, 0), (1, 2, 1)) is True
|
|
assert sdm_monomial_divides((5, 1, 1), (5, 2, 1)) is True
|
|
|
|
assert sdm_monomial_divides((1, 0, 0), (2, 0, 0)) is False
|
|
assert sdm_monomial_divides((1, 1, 0), (1, 0, 0)) is False
|
|
assert sdm_monomial_divides((5, 1, 2), (5, 0, 1)) is False
|
|
|
|
|
|
def test_sdm_LC():
|
|
assert sdm_LC([((1, 2, 3), QQ(5))], QQ) == QQ(5)
|
|
|
|
|
|
def test_sdm_from_dict():
|
|
dic = {(1, 2, 1, 1): QQ(1), (1, 1, 2, 1): QQ(1), (1, 0, 2, 1): QQ(1),
|
|
(1, 0, 0, 3): QQ(1), (1, 1, 1, 0): QQ(1)}
|
|
assert sdm_from_dict(dic, grlex) == \
|
|
[((1, 2, 1, 1), QQ(1)), ((1, 1, 2, 1), QQ(1)),
|
|
((1, 0, 2, 1), QQ(1)), ((1, 0, 0, 3), QQ(1)), ((1, 1, 1, 0), QQ(1))]
|
|
|
|
# TODO test to_dict?
|
|
|
|
|
|
def test_sdm_add():
|
|
assert sdm_add([((1, 1, 1), QQ(1))], [((2, 0, 0), QQ(1))], lex, QQ) == \
|
|
[((2, 0, 0), QQ(1)), ((1, 1, 1), QQ(1))]
|
|
assert sdm_add([((1, 1, 1), QQ(1))], [((1, 1, 1), QQ(-1))], lex, QQ) == []
|
|
assert sdm_add([((1, 0, 0), QQ(1))], [((1, 0, 0), QQ(2))], lex, QQ) == \
|
|
[((1, 0, 0), QQ(3))]
|
|
assert sdm_add([((1, 0, 1), QQ(1))], [((1, 1, 0), QQ(1))], lex, QQ) == \
|
|
[((1, 1, 0), QQ(1)), ((1, 0, 1), QQ(1))]
|
|
|
|
|
|
def test_sdm_LM():
|
|
dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(1), (4, 0, 1): QQ(1)}
|
|
assert sdm_LM(sdm_from_dict(dic, lex)) == (4, 0, 1)
|
|
|
|
|
|
def test_sdm_LT():
|
|
dic = {(1, 2, 3): QQ(1), (4, 0, 0): QQ(2), (4, 0, 1): QQ(3)}
|
|
assert sdm_LT(sdm_from_dict(dic, lex)) == ((4, 0, 1), QQ(3))
|
|
|
|
|
|
def test_sdm_mul_term():
|
|
assert sdm_mul_term([((1, 0, 0), QQ(1))], ((0, 0), QQ(0)), lex, QQ) == []
|
|
assert sdm_mul_term([], ((1, 0), QQ(1)), lex, QQ) == []
|
|
assert sdm_mul_term([((1, 0, 0), QQ(1))], ((1, 0), QQ(1)), lex, QQ) == \
|
|
[((1, 1, 0), QQ(1))]
|
|
f = [((2, 0, 1), QQ(4)), ((1, 1, 0), QQ(3))]
|
|
assert sdm_mul_term(f, ((1, 1), QQ(2)), lex, QQ) == \
|
|
[((2, 1, 2), QQ(8)), ((1, 2, 1), QQ(6))]
|
|
|
|
|
|
def test_sdm_zero():
|
|
assert sdm_zero() == []
|
|
|
|
|
|
def test_sdm_deg():
|
|
assert sdm_deg([((1, 2, 3), 1), ((10, 0, 1), 1), ((2, 3, 4), 4)]) == 7
|
|
|
|
|
|
def test_sdm_spoly():
|
|
f = [((2, 1, 1), QQ(1)), ((1, 0, 1), QQ(1))]
|
|
g = [((2, 3, 0), QQ(1))]
|
|
h = [((1, 2, 3), QQ(1))]
|
|
assert sdm_spoly(f, h, lex, QQ) == []
|
|
assert sdm_spoly(f, g, lex, QQ) == [((1, 2, 1), QQ(1))]
|
|
|
|
|
|
def test_sdm_ecart():
|
|
assert sdm_ecart([((1, 2, 3), 1), ((1, 0, 1), 1)]) == 0
|
|
assert sdm_ecart([((2, 2, 1), 1), ((1, 5, 1), 1)]) == 3
|
|
|
|
|
|
def test_sdm_nf_mora():
|
|
f = sdm_from_dict({(1, 2, 1, 1): QQ(1), (1, 1, 2, 1): QQ(1),
|
|
(1, 0, 2, 1): QQ(1), (1, 0, 0, 3): QQ(1), (1, 1, 1, 0): QQ(1)},
|
|
grlex)
|
|
f1 = sdm_from_dict({(1, 1, 1, 0): QQ(1), (1, 0, 2, 0): QQ(1),
|
|
(1, 0, 0, 0): QQ(-1)}, grlex)
|
|
f2 = sdm_from_dict({(1, 1, 1, 0): QQ(1)}, grlex)
|
|
(id0, id1, id2) = [sdm_from_dict({(i, 0, 0, 0): QQ(1)}, grlex)
|
|
for i in range(3)]
|
|
|
|
assert sdm_nf_mora(f, [f1, f2], grlex, QQ, phantom=(id0, [id1, id2])) == \
|
|
([((1, 0, 2, 1), QQ(1)), ((1, 0, 0, 3), QQ(1)), ((1, 1, 1, 0), QQ(1)),
|
|
((1, 1, 0, 1), QQ(1))],
|
|
[((1, 1, 0, 1), QQ(-1)), ((0, 0, 0, 0), QQ(1))])
|
|
assert sdm_nf_mora(f, [f2, f1], grlex, QQ, phantom=(id0, [id2, id1])) == \
|
|
([((1, 0, 2, 1), QQ(1)), ((1, 0, 0, 3), QQ(1)), ((1, 1, 1, 0), QQ(1))],
|
|
[((2, 1, 0, 1), QQ(-1)), ((2, 0, 1, 1), QQ(-1)), ((0, 0, 0, 0), QQ(1))])
|
|
|
|
f = sdm_from_vector([x*z, y**2 + y*z - z, y], lex, QQ, gens=[x, y, z])
|
|
f1 = sdm_from_vector([x, y, 1], lex, QQ, gens=[x, y, z])
|
|
f2 = sdm_from_vector([x*y, z, z**2], lex, QQ, gens=[x, y, z])
|
|
assert sdm_nf_mora(f, [f1, f2], lex, QQ) == \
|
|
sdm_nf_mora(f, [f2, f1], lex, QQ) == \
|
|
[((1, 0, 1, 1), QQ(1)), ((1, 0, 0, 1), QQ(-1)), ((0, 1, 1, 0), QQ(-1)),
|
|
((0, 1, 0, 1), QQ(1))]
|
|
|
|
|
|
def test_conversion():
|
|
f = [x**2 + y**2, 2*z]
|
|
g = [((1, 0, 0, 1), QQ(2)), ((0, 2, 0, 0), QQ(1)), ((0, 0, 2, 0), QQ(1))]
|
|
assert sdm_to_vector(g, [x, y, z], QQ) == f
|
|
assert sdm_from_vector(f, lex, QQ) == g
|
|
assert sdm_from_vector(
|
|
[x, 1], lex, QQ) == [((1, 0), QQ(1)), ((0, 1), QQ(1))]
|
|
assert sdm_to_vector([((1, 1, 0, 0), 1)], [x, y, z], QQ, n=3) == [0, x, 0]
|
|
assert sdm_from_vector([0, 0], lex, QQ, gens=[x, y]) == sdm_zero()
|
|
|
|
|
|
def test_nontrivial():
|
|
gens = [x, y, z]
|
|
|
|
def contains(I, f):
|
|
S = [sdm_from_vector([g], lex, QQ, gens=gens) for g in I]
|
|
G = sdm_groebner(S, sdm_nf_mora, lex, QQ)
|
|
return sdm_nf_mora(sdm_from_vector([f], lex, QQ, gens=gens),
|
|
G, lex, QQ) == sdm_zero()
|
|
|
|
assert contains([x, y], x)
|
|
assert contains([x, y], x + y)
|
|
assert not contains([x, y], 1)
|
|
assert not contains([x, y], z)
|
|
assert contains([x**2 + y, x**2 + x], x - y)
|
|
assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
|
|
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**3)
|
|
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4)
|
|
assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y**2)
|
|
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x**4 + y**3 + 2*z*y*x)
|
|
assert contains([x + y + z, x*y + x*z + y*z, x*y*z], x*y*z)
|
|
assert contains([x, 1 + x + y, 5 - 7*y], 1)
|
|
assert contains(
|
|
[x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
|
|
x**3)
|
|
assert not contains(
|
|
[x**3 + y**3, y**3 + z**3, z**3 + x**3, x**2*y + x**2*z + y**2*z],
|
|
x**2 + y**2)
|
|
|
|
# compare local order
|
|
assert not contains([x*(1 + x + y), y*(1 + z)], x)
|
|
assert not contains([x*(1 + x + y), y*(1 + z)], x + y)
|
|
|
|
|
|
def test_local():
|
|
igrlex = InverseOrder(grlex)
|
|
gens = [x, y, z]
|
|
|
|
def contains(I, f):
|
|
S = [sdm_from_vector([g], igrlex, QQ, gens=gens) for g in I]
|
|
G = sdm_groebner(S, sdm_nf_mora, igrlex, QQ)
|
|
return sdm_nf_mora(sdm_from_vector([f], lex, QQ, gens=gens),
|
|
G, lex, QQ) == sdm_zero()
|
|
assert contains([x, y], x)
|
|
assert contains([x, y], x + y)
|
|
assert not contains([x, y], 1)
|
|
assert not contains([x, y], z)
|
|
assert contains([x**2 + y, x**2 + x], x - y)
|
|
assert not contains([x + y + z, x*y + x*z + y*z, x*y*z], x**2)
|
|
assert contains([x*(1 + x + y), y*(1 + z)], x)
|
|
assert contains([x*(1 + x + y), y*(1 + z)], x + y)
|
|
|
|
|
|
def test_uncovered_line():
|
|
gens = [x, y]
|
|
f1 = sdm_zero()
|
|
f2 = sdm_from_vector([x, 0], lex, QQ, gens=gens)
|
|
f3 = sdm_from_vector([0, y], lex, QQ, gens=gens)
|
|
|
|
assert sdm_spoly(f1, f2, lex, QQ) == sdm_zero()
|
|
assert sdm_spoly(f3, f2, lex, QQ) == sdm_zero()
|
|
|
|
|
|
def test_chain_criterion():
|
|
gens = [x]
|
|
f1 = sdm_from_vector([1, x], grlex, QQ, gens=gens)
|
|
f2 = sdm_from_vector([0, x - 2], grlex, QQ, gens=gens)
|
|
assert len(sdm_groebner([f1, f2], sdm_nf_mora, grlex, QQ)) == 2
|