def test_issue_7842():
A = MatrixSymbol('A', 3, 1)
B = MatrixSymbol('B', 2, 1)
assert Eq(A, B) == False
assert Eq(A[1, 0], B[1, 0]).func is Eq
A = ZeroMatrix(2, 3)
B = ZeroMatrix(2, 3)
assert Eq(A, B) == True
def constraints_to_matrix(
inequalities: List[relational.GreaterThan],
dependents: List[Symbol],
as_numeric: bool = False,
) -> Tuple[Matrix, Matrix]:
"""Converts list of linear inequalities to slack variable matrix-vector equations.
The result relates to the original eqn such that ``m@(deps, s) + b = 0``
Arguments:
inequalities:
List of relational equations. LHS must be linear in dependents, RHS constant.
dependents:
List of dependent variables.
as_numeric:
Convert sympy matrix to float if possible.
Returns:
m and v, here m is the Matrix and v the vector containing the slack variable
Example:
For example ``[a1 * x - b1 <= 0, a2 * x - b2 >= 0)]`` becomes
```
a = | +a1 s1 0 | and b = | +b1 |
| -a2 0 s2 | | -b2 |
```
"""
for ieqn in inequalities:
if not ieqn.rhs == 0:
raise TypeError("RHS of inequality must be zero. Received %s" %
ieqn.rhs)
n_deps = len(dependents)
n_eqns = len(inequalities)
a = ZeroMatrix(rows=n_eqns, cols=(n_deps + n_eqns))
b = ZeroMatrix(rows=n_eqns, cols=1)
for ne, ieqn in enumerate(inequalities):
if isinstance(ieqn, relational.LessThan):
ieqn = ieqn.lhs * (-1) >= 0
elif isinstance(ieqn, relational.GreaterThan):
pass
else:
raise TypeError(
"All inequalities must be either of form '>=' or '<='. Received %s."
% type(ieqn))
for nd, dep in enumerate(dependents):
a[ne, nd] = ieqn.lhs.coeff(dep)
a[ne, n_deps + ne] = -1
b[ne, 0] = ieqn.lhs.subs({dep: 0 for dep in dependents})
return (np.array(a), np.array(b)) if as_numeric else (a, b)
def test_ZeroMatrix():
n, m = symbols('n m', integer=True)
A = MatrixSymbol('A', n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A * Z.T == ZeroMatrix(n, n)
assert Z * A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert Transpose(Z) == ZeroMatrix(m, n)
def test_ZeroMatrix():
A = MatrixSymbol('A', n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A*Z.T == ZeroMatrix(n, n)
assert Z*A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert Transpose(Z) == ZeroMatrix(m, n)
assert Z.conjugate() == Z
def test_ZeroMatrix():
n, m = symbols("n m", integer=True)
A = MatrixSymbol("A", n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A * Z.T == ZeroMatrix(n, n)
assert Z * A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert Transpose(Z) == ZeroMatrix(m, n)
assert Z.conjugate() == Z
def test_Zero_power():
z1 = ZeroMatrix(n, n)
assert z1**4 == z1
raises(ValueError, lambda: z1**-2)
assert z1**0 == Identity(n)
assert MatPow(z1, 2).doit() == z1**2
raises(ValueError, lambda: MatPow(z1, -2).doit())
z2 = ZeroMatrix(3, 3)
assert MatPow(z2, 4).doit() == z2**4
raises(ValueError, lambda: z2**-3)
assert z2**3 == MatPow(z2, 3).doit()
assert z2**0 == Identity(3)
raises(ValueError, lambda: MatPow(z2, -1).doit())
def test_MatAdd():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', n, m)
assert (A + B).shape == A.shape
assert MatAdd(A, -A, 2 * B).is_MatMul
raises(ShapeError, lambda: A + B.T)
raises(TypeError, lambda: A + 1)
raises(TypeError, lambda: 5 + A)
raises(TypeError, lambda: 5 - A)
assert MatAdd(A, ZeroMatrix(n, m), -A) == ZeroMatrix(n, m)
def test_zero_power():
z1 = ZeroMatrix(n, n)
assert MatPow(z1, 3).doit() == z1
raises(ValueError, lambda:MatPow(z1, -1).doit())
assert MatPow(z1, 0).doit() == Identity(n)
assert MatPow(z1, n).doit() == z1
raises(ValueError, lambda:MatPow(z1, -2).doit())
z2 = ZeroMatrix(4, 4)
assert MatPow(z2, n).doit() == z2
raises(ValueError, lambda:MatPow(z2, -3).doit())
assert MatPow(z2, 2).doit() == z2
assert MatPow(z2, 0).doit() == Identity(4)
raises(ValueError, lambda:MatPow(z2, -1).doit())
def test_MatAdd():
n, m = symbols('n m', integer=True)
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', n, m)
assert (A + B).shape == A.shape
assert MatAdd(A, -A, 2 * B).is_Mul
raises(ShapeError, lambda: A + B.T)
raises(ValueError, lambda: A + 1)
raises(ValueError, lambda: 5 + A)
raises(ValueError, lambda: 5 - A)
assert MatAdd(A, ZeroMatrix(n, m), -A) == ZeroMatrix(n, m)
assert MatAdd(ZeroMatrix(n, m), S(0)) == ZeroMatrix(n, m)
def test_MatMul_postprocessor():
z = zeros(2)
z1 = ZeroMatrix(2, 2)
assert Mul(0, z) == Mul(z, 0) in [z, z1]
M = Matrix([[1, 2], [3, 4]])
Mx = Matrix([[x, 2*x], [3*x, 4*x]])
assert Mul(x, M) == Mul(M, x) == Mx
A = MatrixSymbol("A", 2, 2)
assert Mul(A, M) == MatMul(A, M)
assert Mul(M, A) == MatMul(M, A)
# Scalars should be absorbed into constant matrices
a = Mul(x, M, A)
b = Mul(M, x, A)
c = Mul(M, A, x)
assert a == b == c == MatMul(Mx, A)
a = Mul(x, A, M)
b = Mul(A, x, M)
c = Mul(A, M, x)
assert a == b == c == MatMul(A, Mx)
assert Mul(M, M) == M**2
assert Mul(A, M, M) == MatMul(A, M**2)
assert Mul(M, M, A) == MatMul(M**2, A)
assert Mul(M, A, M) == MatMul(M, A, M)
assert Mul(A, x, M, M, x) == MatMul(A, Mx**2)
def test_trace():
n, m, l = symbols('n m l', integer=True)
A = MatrixSymbol('A', n, n)
B = MatrixSymbol('B', n, n)
assert isinstance(Trace(A), Trace)
assert not isinstance(Trace(A), MatrixExpr)
raises(ShapeError, lambda: Trace(MatrixSymbol('B', 3, 4)))
assert Trace(eye(3)) == 3
assert Trace(Matrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9])) == 15
A / Trace(A) # Make sure this is possible
# Some easy simplifications
assert Trace(Identity(5)) == 5
assert Trace(ZeroMatrix(5, 5)) == 0
assert Trace(2 * A * B) == 2 * Trace(A * B)
assert Trace(A.T) == Trace(A)
i, j = symbols('i,j')
F = FunctionMatrix(3, 3, Lambda((i, j), i + j))
assert Trace(F).doit() == (0 + 0) + (1 + 1) + (2 + 2)
raises(TypeError, lambda: Trace(S.One))
assert Trace(A).arg is A
def test_addition():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', n, m)
assert isinstance(A + B, MatAdd)
assert (A + B).shape == A.shape
assert isinstance(A - A + 2 * B, MatMul)
raises(ShapeError, lambda: A + B.T)
raises(TypeError, lambda: A + 1)
raises(TypeError, lambda: 5 + A)
raises(TypeError, lambda: 5 - A)
assert A + ZeroMatrix(n, m) - A == ZeroMatrix(n, m)
with raises(TypeError):
ZeroMatrix(n, m) + S(0)
def test_ZeroMatrix():
A = MatrixSymbol('A', n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A*Z.T == ZeroMatrix(n, n)
assert Z*A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert transpose(Z) == ZeroMatrix(m, n)
assert Z.conjugate() == Z
assert ZeroMatrix(n, n)**0 == Identity(n)
with raises(ShapeError):
Z**0
with raises(ShapeError):
Z**2
def test_invariants():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
X = MatrixSymbol('X', n, n)
objs = [Identity(n), ZeroMatrix(m, n), A, MatMul(A, B), MatAdd(A, A),
Transpose(A), Adjoint(A), Inverse(X), MatPow(X, 2), MatPow(X, -1),
MatPow(X, 0)]
for obj in objs:
assert obj == obj.__class__(*obj.args)
def test_matexpr():
n, m, l = symbols('n m l', integer=True)
x = Symbol('x')
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
assert (x * A).shape == A.shape
assert (x * A).__class__ == MatMul
assert 2 * A - A - A == ZeroMatrix(*A.shape)
def test_MatMul():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
C = MatrixSymbol('C', n, n)
assert (2 * A * B).shape == (n, l)
assert (A * 0 * B) == ZeroMatrix(n, l)
raises(ShapeError, lambda: B * A)
assert (2 * A).shape == A.shape
assert MatMul(A, ZeroMatrix(m, m), B) == ZeroMatrix(n, l)
assert MatMul(C * Identity(n) * C.I) == Identity(n)
assert B / 2 == S.Half * B
raises(NotImplementedError, lambda: 2 / B)
A = MatrixSymbol('A', n, n)
B = MatrixSymbol('B', n, n)
assert MatMul(Identity(n), (A + B)).is_MatAdd
def test_ZeroMatrix():
A = MatrixSymbol('A', n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A * Z.T == ZeroMatrix(n, n)
assert Z * A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert Transpose(Z) == ZeroMatrix(m, n)
assert Z.conjugate() == Z
def test_multiplication():
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
C = MatrixSymbol('C', n, n)
assert (2 * A * B).shape == (n, l)
assert (A * 0 * B) == ZeroMatrix(n, l)
raises(ShapeError, lambda: B * A)
assert (2 * A).shape == A.shape
assert A * ZeroMatrix(m, m) * B == ZeroMatrix(n, l)
assert C * Identity(n) * C.I == Identity(n)
assert B / 2 == S.Half * B
raises(NotImplementedError, lambda: 2 / B)
A = MatrixSymbol('A', n, n)
B = MatrixSymbol('B', n, n)
assert Identity(n) * (A + B) == A + B
def test_zero_matrix_creation():
assert unchanged(ZeroMatrix, 2, 2)
assert unchanged(ZeroMatrix, 0, 0)
raises(ValueError, lambda: ZeroMatrix(-1, 2))
raises(ValueError, lambda: ZeroMatrix(2.0, 2))
raises(ValueError, lambda: ZeroMatrix(2j, 2))
raises(ValueError, lambda: ZeroMatrix(2, -1))
raises(ValueError, lambda: ZeroMatrix(2, 2.0))
raises(ValueError, lambda: ZeroMatrix(2, 2j))
n = symbols('n')
assert unchanged(ZeroMatrix, n, n)
n = symbols('n', integer=False)
raises(ValueError, lambda: ZeroMatrix(n, n))
n = symbols('n', negative=True)
raises(ValueError, lambda: ZeroMatrix(n, n))
def test_MatMul():
n, m, l = symbols('n m l', integer=True)
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
C = MatrixSymbol('C', n, n)
assert (2 * A * B).shape == (n, l)
assert (A * 0 * B) == ZeroMatrix(n, l)
raises(ShapeError, "B*A")
assert (2 * A).shape == A.shape
assert MatMul(A, ZeroMatrix(m, m), B) == ZeroMatrix(n, l)
assert MatMul(C * Identity(n) * C.I) == Identity(n)
assert B / 2 == S.Half * B
raises(NotImplementedError, "2/B")
A = MatrixSymbol('A', n, n)
B = MatrixSymbol('B', n, n)
assert MatMul(Identity(n), (A + B)).is_Add
def test_ZeroMatrix():
A = MatrixSymbol('A', n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A * Z.T == ZeroMatrix(n, n)
assert Z * A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert transpose(Z) == ZeroMatrix(m, n)
assert Z.conjugate() == Z
assert ZeroMatrix(n, n)**0 == Identity(n)
with raises(ShapeError):
Z**0
with raises(ShapeError):
Z**2
def test_ZeroMatrix():
A = MatrixSymbol('A', n, m)
Z = ZeroMatrix(n, m)
assert A + Z == A
assert A*Z.T == ZeroMatrix(n, n)
assert Z*A.T == ZeroMatrix(n, n)
assert A - A == ZeroMatrix(*A.shape)
assert Z
assert transpose(Z) == ZeroMatrix(m, n)
assert Z.conjugate() == Z
assert ZeroMatrix(n, n)**0 == Identity(n)
with raises(NonSquareMatrixError):
Z**0
with raises(NonSquareMatrixError):
Z**1
with raises(NonSquareMatrixError):
Z**2
assert ZeroMatrix(3, 3).as_explicit() == ImmutableMatrix.zeros(3, 3)
def test_MatrixSet():
M = MatrixSet(2, 2, set=S.Reals)
assert M.shape == (2, 2)
assert M.set == S.Reals
X = Matrix([[1, 2], [3, 4]])
assert X in M
X = ZeroMatrix(2, 2)
assert X in M
raises(TypeError, lambda: A in M)
raises(TypeError, lambda: 1 in M)
M = MatrixSet(n, m, set=S.Reals)
assert A in M
raises(TypeError, lambda: C in M)
raises(TypeError, lambda: X in M)
M = MatrixSet(2, 2, set={1, 2, 3})
X = Matrix([[1, 2], [3, 4]])
Y = Matrix([[1, 2]])
assert (X in M) == S.false
assert (Y in M) == S.false
raises(ValueError, lambda: MatrixSet(2, -2, S.Reals))
raises(ValueError, lambda: MatrixSet(2.4, -1, S.Reals))
raises(TypeError, lambda: MatrixSet(2, 2, (1, 2, 3)))
def test_linear_factors():
from sympy.matrices import MatrixSymbol, linear_factors
n, m, l = symbols('n m l')
A = MatrixSymbol('A', n, m)
B = MatrixSymbol('B', m, l)
C = MatrixSymbol('C', n, l)
assert linear_factors(2 * A * B + C, B, C) == {C: Identity(n), B: 2 * A}
assert linear_factors(2 * A * B + C, B) == {B: 2 * A}
assert linear_factors(2 * A * B, B) == {B: 2 * A}
assert linear_factors(2 * A * B, C) == {C: ZeroMatrix(n, n)}
A = MatrixSymbol('A', n, n)
B = MatrixSymbol('B', n, n)
C = MatrixSymbol('C', n, n)
D = MatrixSymbol('C', m, m)
raises(ValueError, lambda: linear_factors(2 * A * A + B, A))
raises(ValueError, lambda: linear_factors(2 * A * A, A))
raises(ValueError, lambda: linear_factors(2 * A * B, A, B))
raises(ShapeError, lambda: linear_factors(2 * A * B, D))
raises(ShapeError, lambda: linear_factors(2 * A * B + C, D))
assert linear_factors(A, A) == {A: Identity(n)}
def test_ZeroMatrix_doit():
Znn = ZeroMatrix(Add(n, n, evaluate=False), n)
assert isinstance(Znn.rows, Add)
assert Znn.doit() == ZeroMatrix(2*n, n)
assert isinstance(Znn.doit().rows, Mul)
def test_any_zeros():
assert any_zeros(MatMul(A, ZeroMatrix(m, k), evaluate=False)) == \
ZeroMatrix(n, k)
def test_ZeroMatrix_doit():
Znn = ZeroMatrix(Add(n, n, evaluate=False), n)
assert isinstance(Znn.rows, Add)
assert Znn.doit() == ZeroMatrix(2 * n, n)
assert isinstance(Znn.doit().rows, Mul)
def test_matexpr():
assert (x * A).shape == A.shape
assert (x * A).__class__ == MatMul
assert 2 * A - A - A == ZeroMatrix(*A.shape)
assert (A * B).shape == (n, l)
def test_str_special_matrices():
from sympy.matrices import Identity, ZeroMatrix, OneMatrix
assert str(Identity(4)) == 'I'
assert str(ZeroMatrix(2, 2)) == '0'
assert str(OneMatrix(2, 2)) == '1'
