def test_smith_normal():
m = DM([[12, 6, 4, 8], [3, 9, 6, 12], [2, 16, 14, 28], [20, 10, 10, 20]],
ZZ)
smf = DM([[1, 0, 0, 0], [0, 10, 0, 0], [0, 0, -30, 0], [0, 0, 0, 0]], ZZ)
assert smith_normal_form(m).to_dense() == smf
x = Symbol('x')
m = DM([[x - 1, 1, -1], [0, x, -1], [0, -1, x]], QQ[x])
dx = m.domain.gens[0]
assert invariant_factors(m) == (1, dx - 1, dx**2 - 1)
zr = DomainMatrix([], (0, 2), ZZ)
zc = DomainMatrix([[], []], (2, 0), ZZ)
assert smith_normal_form(zr).to_dense() == zr
assert smith_normal_form(zc).to_dense() == zc
assert smith_normal_form(DM([[2, 4]], ZZ)).to_dense() == DM([[2, 0]], ZZ)
assert smith_normal_form(DM([[0, -2]], ZZ)).to_dense() == DM([[-2, 0]], ZZ)
assert smith_normal_form(DM([[0], [-2]], ZZ)).to_dense() == DM([[-2], [0]],
ZZ)
m = DM([[3, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0]], ZZ)
snf = DM([[1, 0, 0, 0], [0, 6, 0, 0], [0, 0, 0, 0]], ZZ)
assert smith_normal_form(m).to_dense() == snf
raises(ValueError, lambda: smith_normal_form(DM([[1]], ZZ[x])))
def test_Submodule_mul():
T = Poly(cyclotomic_poly(5, x))
A = PowerBasis(T)
C = A.submodule_from_matrix(DomainMatrix([
[0, 10, 0, 0],
[0, 0, 7, 0],
], (2, 4), ZZ).transpose(),
denom=15)
C1 = A.submodule_from_matrix(DomainMatrix([
[0, 20, 0, 0],
[0, 0, 14, 0],
], (2, 4), ZZ).transpose(),
denom=3)
C2 = A.submodule_from_matrix(DomainMatrix([
[0, 0, 10, 0],
[0, 0, 0, 7],
], (2, 4), ZZ).transpose(),
denom=15)
C3_unred = A.submodule_from_matrix(DomainMatrix(
[[0, 0, 100, 0], [0, 0, 0, 70], [0, 0, 0, 70], [-49, -49, -49, -49]],
(4, 4), ZZ).transpose(),
denom=225)
C3 = A.submodule_from_matrix(DomainMatrix(
[[4900, 4900, 0, 0], [4410, 4410, 10, 0], [2107, 2107, 7, 7]], (3, 4),
ZZ).transpose(),
denom=225)
assert C * 1 == C
assert C**1 == C
assert C * 10 == C1
assert C * A(1) == C2
assert C.mul(C, hnf=False) == C3_unred
assert C * C == C3
assert C**2 == C3
def test_smith_normal():
def DM(elems, domain):
conv = lambda e: domain.from_sympy(sympify(e))
elems = [[conv(e) for e in row] for row in elems]
return DomainMatrix(elems, (len(elems), len(elems[0])), domain)
m = DM([[12, 6, 4, 8], [3, 9, 6, 12], [2, 16, 14, 28], [20, 10, 10, 20]], ZZ)
smf = DM([[1, 0, 0, 0], [0, 10, 0, 0], [0, 0, -30, 0], [0, 0, 0, 0]], ZZ)
assert smith_normal_form(m).to_dense() == smf
x = Symbol('x')
m = DM([[x-1, 1, -1],
[ 0, x, -1],
[ 0, -1, x]], QQ[x])
dx = m.domain.gens[0]
assert invariant_factors(m) == (1, dx-1, dx**2-1)
zr = DomainMatrix([], (0, 2), ZZ)
zc = DomainMatrix([[], []], (2, 0), ZZ)
assert smith_normal_form(zr).to_dense() == zr
assert smith_normal_form(zc).to_dense() == zc
assert smith_normal_form(DM([[2, 4]], ZZ)).to_dense() == DM([[2, 0]], ZZ)
assert smith_normal_form(DM([[0, -2]], ZZ)).to_dense() == DM([[-2, 0]], ZZ)
assert smith_normal_form(DM([[0], [-2]], ZZ)).to_dense() == DM([[-2], [0]], ZZ)
m = DM([[3, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0]], ZZ)
snf = DM([[1, 0, 0, 0], [0, 6, 0, 0], [0, 0, 0, 0]], ZZ)
assert smith_normal_form(m).to_dense() == snf
raises(ValueError, lambda: smith_normal_form(DM([[1]], ZZ[x])))
def test_Submodule_add():
T = Poly(cyclotomic_poly(5, x))
A = PowerBasis(T)
B = A.submodule_from_matrix(DomainMatrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
], (2, 4), ZZ).transpose(),
denom=6)
C = A.submodule_from_matrix(DomainMatrix([
[0, 10, 0, 0],
[0, 0, 7, 0],
], (2, 4), ZZ).transpose(),
denom=15)
D = A.submodule_from_matrix(DomainMatrix([
[20, 0, 0, 0],
[0, 20, 0, 0],
[0, 0, 14, 0],
], (3, 4), ZZ).transpose(),
denom=30)
assert B + C == D
U = Poly(cyclotomic_poly(7, x))
Z = PowerBasis(U)
Y = Z.submodule_from_gens([Z(0), Z(1)])
raises(TypeError, lambda: B + Y)
def test_EndomorphismRing_represent():
T = Poly(cyclotomic_poly(5, x))
A = PowerBasis(T)
R = A.endomorphism_ring()
phi = R.inner_endomorphism(A(1))
col = R.represent(phi)
assert col.transpose() == DomainMatrix(
[[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, -1, -1, -1, -1]], (1, 16), ZZ)
B = A.submodule_from_matrix(DomainMatrix.zeros((4, 0), ZZ))
S = B.endomorphism_ring()
psi = S.inner_endomorphism(A(1))
col = S.represent(psi)
assert col == DomainMatrix([], (0, 0), ZZ)
raises(NotImplementedError, lambda: R.represent(3.14))
def test_Submodule_reduce_element():
T = Poly(cyclotomic_poly(5, x))
A = PowerBasis(T)
B = A.whole_submodule()
b = B(to_col([90, 84, 80, 75]), denom=120)
C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=2)
b_bar_expected = B(to_col([30, 24, 20, 15]), denom=120)
b_bar = C.reduce_element(b)
assert b_bar == b_bar_expected
C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=4)
b_bar_expected = B(to_col([0, 24, 20, 15]), denom=120)
b_bar = C.reduce_element(b)
assert b_bar == b_bar_expected
C = B.submodule_from_matrix(DomainMatrix.eye(4, ZZ), denom=8)
b_bar_expected = B(to_col([0, 9, 5, 0]), denom=120)
b_bar = C.reduce_element(b)
assert b_bar == b_bar_expected
a = A(to_col([1, 2, 3, 4]))
raises(NotImplementedError, lambda: C.reduce_element(a))
C = B.submodule_from_matrix(
DomainMatrix(
[[5, 4, 3, 2], [0, 8, 7, 6], [0, 0, 11, 12], [0, 0, 0, 1]], (4, 4),
ZZ).transpose())
raises(StructureError, lambda: C.reduce_element(b))
def test_Submodule_represent():
T = Poly(cyclotomic_poly(5, x))
A = PowerBasis(T)
B = A.submodule_from_matrix(2 * DomainMatrix.eye(4, ZZ))
C = B.submodule_from_matrix(3 * DomainMatrix.eye(4, ZZ))
a0 = A(to_col([6, 12, 18, 24]))
a1 = A(to_col([2, 4, 6, 8]))
a2 = A(to_col([1, 3, 5, 7]))
b1 = B.represent(a1)
assert b1.flat() == [1, 2, 3, 4]
c0 = C.represent(a0)
assert c0.flat() == [1, 2, 3, 4]
Y = A.submodule_from_matrix(
DomainMatrix([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
], (3, 4), ZZ).transpose())
U = Poly(cyclotomic_poly(7, x))
Z = PowerBasis(U)
z0 = Z(to_col([1, 2, 3, 4, 5, 6]))
raises(ClosureFailure, lambda: Y.represent(A(3)))
raises(ClosureFailure, lambda: B.represent(a2))
raises(ClosureFailure, lambda: B.represent(z0))
def test_ModuleHomomorphism_matrix():
T = Poly(cyclotomic_poly(5, x))
A = PowerBasis(T)
phi = ModuleEndomorphism(A, lambda a: a**2)
M = phi.matrix()
assert M == DomainMatrix(
[[1, 0, -1, 0], [0, 0, -1, 1], [0, 1, -1, 0], [0, 0, -1, 0]], (4, 4),
ZZ)
def _dod_to_DomainMatrix(cls, rows, cols, dod, types):
if not all(issubclass(typ, Expr) for typ in types):
SymPyDeprecationWarning(
feature="non-Expr objects in a Matrix",
useinstead="list of lists, TableForm or some other data structure",
issue=21497,
deprecated_since_version="1.9"
).warn()
rep = DomainMatrix(dod, (rows, cols), EXRAW)
if all(issubclass(typ, Rational) for typ in types):
if all(issubclass(typ, Integer) for typ in types):
rep = rep.convert_to(ZZ)
else:
rep = rep.convert_to(QQ)
return rep
def fill(self, value):
"""Fill self with the given value.
Notes
=====
Unless many values are going to be deleted (i.e. set to zero)
this will create a matrix that is slower than a dense matrix in
operations.
Examples
========
>>> from sympy.matrices import SparseMatrix
>>> M = SparseMatrix.zeros(3); M
Matrix([
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
>>> M.fill(1); M
Matrix([
[1, 1, 1],
[1, 1, 1],
[1, 1, 1]])
See Also
========
zeros
ones
"""
value = _sympify(value)
if not value:
self._rep = DomainMatrix.zeros(self.shape, EXRAW)
else:
elements_dod = {
i: {j: value
for j in range(self.cols)}
for i in range(self.rows)
}
self._rep = DomainMatrix(elements_dod, self.shape, EXRAW)
def from_list(cls, rows, cols, items, gens, ring):
# items can be Expr, Poly, or a mix of Expr and Poly
items = [_sympify(item) for item in items]
if items and all(isinstance(item, Poly) for item in items):
polys = True
else:
polys = False
# Identify the ring for the polys
if ring is not None:
# Parse a domain string like 'QQ[x]'
if isinstance(ring, str):
ring = Poly(0, Dummy(), domain=ring).domain
elif polys:
p = items[0]
for p2 in items[1:]:
p, _ = p.unify(p2)
ring = p.domain[p.gens]
else:
items, info = parallel_poly_from_expr(items, gens, field=True)
ring = info['domain'][info['gens']]
polys = True
# Efficiently convert when all elements are Poly
if polys:
p_ring = Poly(0, ring.symbols, domain=ring.domain)
to_ring = ring.ring.from_list
convert_poly = lambda p: to_ring(p.unify(p_ring)[0].rep.rep)
elements = [convert_poly(p) for p in items]
else:
convert_expr = ring.from_sympy
elements = [convert_expr(e.as_expr()) for e in items]
# Convert to domain elements and construct DomainMatrix
elements_lol = [[elements[i * cols + j] for j in range(cols)]
for i in range(rows)]
dm = DomainMatrix(elements_lol, (rows, cols), ring)
return cls.from_dm(dm)
def test_hermite_normal():
m = DM([[2, 7, 17, 29, 41], [3, 11, 19, 31, 43], [5, 13, 23, 37, 47]], ZZ)
hnf = DM([[1, 0, 0], [0, 2, 1], [0, 0, 1]], ZZ)
assert hermite_normal_form(m) == hnf
assert hermite_normal_form(m, D=ZZ(2)) == hnf
assert hermite_normal_form(m, D=ZZ(2), check_rank=True) == hnf
m = m.transpose()
hnf = DM([[37, 0, 19], [222, -6, 113], [48, 0, 25], [0, 2, 1], [0, 0, 1]],
ZZ)
assert hermite_normal_form(m) == hnf
raises(DMShapeError, lambda: _hermite_normal_form_modulo_D(m, ZZ(96)))
raises(DMDomainError, lambda: _hermite_normal_form_modulo_D(m, QQ(96)))
m = DM([[8, 28, 68, 116, 164], [3, 11, 19, 31, 43], [5, 13, 23, 37, 47]],
ZZ)
hnf = DM([[4, 0, 0], [0, 2, 1], [0, 0, 1]], ZZ)
assert hermite_normal_form(m) == hnf
assert hermite_normal_form(m, D=ZZ(8)) == hnf
assert hermite_normal_form(m, D=ZZ(8), check_rank=True) == hnf
m = DM([[10, 8, 6, 30, 2], [45, 36, 27, 18, 9], [5, 4, 3, 2, 1]], ZZ)
hnf = DM([[26, 2], [0, 9], [0, 1]], ZZ)
assert hermite_normal_form(m) == hnf
m = DM([[2, 7], [0, 0], [0, 0]], ZZ)
hnf = DM([[1], [0], [0]], ZZ)
assert hermite_normal_form(m) == hnf
m = DM([[-2, 1], [0, 1]], ZZ)
hnf = DM([[2, 1], [0, 1]], ZZ)
assert hermite_normal_form(m) == hnf
m = DomainMatrix([[QQ(1)]], (1, 1), QQ)
raises(DMDomainError, lambda: hermite_normal_form(m))
raises(DMDomainError, lambda: _hermite_normal_form(m))
raises(DMDomainError, lambda: _hermite_normal_form_modulo_D(m, ZZ(1)))
def _dod_to_DomainMatrix(cls, rows, cols, dod, types):
if not all(issubclass(typ, Expr) for typ in types):
sympy_deprecation_warning(
"""
non-Expr objects in a Matrix is deprecated. Matrix represents
a mathematical matrix. To represent a container of non-numeric
entities, Use a list of lists, TableForm, NumPy array, or some
other data structure instead.
""",
deprecated_since_version="1.9",
active_deprecations_target="deprecated-non-expr-in-matrix",
stacklevel=6,
)
rep = DomainMatrix(dod, (rows, cols), EXRAW)
if all(issubclass(typ, Rational) for typ in types):
if all(issubclass(typ, Integer) for typ in types):
rep = rep.convert_to(ZZ)
else:
rep = rep.convert_to(QQ)
return rep
def DM(elems, domain):
conv = lambda e: domain.from_sympy(sympify(e))
elems = [[conv(e) for e in row] for row in elems]
return DomainMatrix(elems, (len(elems), len(elems[0])), domain)