def test_Inverse():
assert Inverse(MatPow(C, 0)).doit() == Identity(n)
assert Inverse(MatPow(C, 1)).doit() == Inverse(C)
assert Inverse(MatPow(C, 2)).doit() == MatPow(C, -2)
assert Inverse(MatPow(C, -1)).doit() == C
assert MatPow(Inverse(C), 0).doit() == Identity(n)
assert MatPow(Inverse(C), 1).doit() == Inverse(C)
assert MatPow(Inverse(C), 2).doit() == MatPow(C, -2)
assert MatPow(Inverse(C), -1).doit() == C
def apply(*given):
unequality, eq = given
if not unequality.is_Unequality:
unequality, eq = eq, unequality
assert unequality.is_Unequality
unequality.rhs.is_zero
assert unequality.lhs.is_Determinant
divisor = unequality.lhs.arg
return Unequal(eq.lhs @ Inverse(divisor),
eq.rhs @ Inverse(divisor),
given=given)
def test_unchanged():
assert unchanged(MatPow, C, 0)
assert unchanged(MatPow, C, 1)
assert unchanged(MatPow, Inverse(C), -1)
assert unchanged(Inverse, MatPow(C, -1), -1)
assert unchanged(MatPow, MatPow(C, -1), -1)
assert unchanged(MatPow, MatPow(C, 1), 1)
def _eval_inverse(self):
try:
return KroneckerProduct(*[a.inverse() for a in self.args])
except ShapeError:
from sympy.matrices.expressions.inverse import Inverse
return Inverse(self)
def apply(given):
assert given.is_Unequality
A_det, zero = given.args
assert A_det.is_Determinant
assert zero.is_zero
A = A_det.arg
return Equality(Cofactors(A).T / Determinant(A), Inverse(A), given=given)
def _eval_inverse(self):
try:
return MatMul(*[
arg.inverse() if isinstance(arg, MatrixExpr) else arg**-1
for arg in self.args[::-1]]).doit()
except ShapeError:
from sympy.matrices.expressions.inverse import Inverse
return Inverse(self)
def bc_inverse(expr):
if isinstance(expr.arg, BlockDiagMatrix):
return expr.inverse()
expr2 = blockinverse_1x1(expr)
if expr != expr2:
return expr2
return blockinverse_2x2(Inverse(reblock_2x2(expr.arg)))
def _eval_inverse(self):
condition = self._is_1x1()
if condition == True:
return Identity(1)
elif condition == False:
raise NonInvertibleMatrixError("Matrix det == 0; not invertible.")
else:
return Inverse(self)
def __pow__(self, other):
if not self.is_square:
raise ShapeError("Power of non-square matrix %s" % self)
if other is S.NegativeOne:
return Inverse(self)
elif other is S.Zero:
return Identity(self.rows)
elif other is S.One:
return self
return MatPow(self, other)
def _eval_inverse(self, expand=False):
# Inverse of one by one block matrix is easy
if self.blockshape == (1, 1):
mat = Matrix(1, 1, (self.blocks[0].inverse(), ))
return BlockMatrix(mat)
# Inverse of a two by two block matrix is known
elif expand and self.blockshape == (2, 2):
# Cite: The Matrix Cookbook Section 9.1.3
A11, A12, A21, A22 = (self.blocks[0, 0], self.blocks[0, 1],
self.blocks[1, 0], self.blocks[1, 1])
C1 = A11 - A12 * A22.I * A21
C2 = A22 - A21 * A11.I * A12
mat = Matrix([[C1.I, (-A11).I * A12 * C2.I],
[-C2.I * A21 * A11.I, C2.I]])
return BlockMatrix(mat)
else:
return Inverse(self)
def test_matrix_derivative_with_inverse():
# Cookbook example 61:
expr = a.T * Inverse(X) * b
assert expr.diff(X) == -Inverse(X).T * a * b.T * Inverse(X).T
# Cookbook example 62:
expr = Determinant(Inverse(X))
# Not implemented yet:
# assert expr.diff(X) == -Determinant(X.inv())*(X.inv()).T
# Cookbook example 63:
expr = Trace(A * Inverse(X) * B)
assert expr.diff(X) == -(X**(-1) * B * A * X**(-1)).T
# Cookbook example 64:
expr = Trace(Inverse(X + A))
assert expr.diff(X) == -(Inverse(X + A)).T**2
def _eval_inverse(self):
from sympy.matrices.expressions.inverse import Inverse
return Inverse(self)
def bc_inverse(expr):
expr2 = blockinverse_1x1(expr)
if expr != expr2:
return expr2
return blockinverse_2x2(Inverse(reblock_2x2(expr.arg)))
def test_sympy__matrices__expressions__inverse__Inverse():
from sympy.matrices.expressions.inverse import Inverse
from sympy.matrices.expressions import MatrixSymbol
assert _test_args(Inverse(MatrixSymbol('A', 3, 3)))
def test_matrix_derivatives_of_traces():
expr = Trace(A) * A
I = Identity(k)
assert expr.diff(A) == ArrayAdd(
ArrayTensorProduct(I, A),
PermuteDims(ArrayTensorProduct(Trace(A) * I, I),
Permutation(3)(1, 2)))
assert expr[i, j].diff(
A[m, n]).doit() == (KDelta(i, m) * KDelta(j, n) * Trace(A) +
KDelta(m, n) * A[i, j])
## First order:
# Cookbook example 99:
expr = Trace(X)
assert expr.diff(X) == Identity(k)
assert expr.rewrite(Sum).diff(X[m, n]).doit() == KDelta(m, n)
# Cookbook example 100:
expr = Trace(X * A)
assert expr.diff(X) == A.T
assert expr.rewrite(Sum).diff(X[m, n]).doit() == A[n, m]
# Cookbook example 101:
expr = Trace(A * X * B)
assert expr.diff(X) == A.T * B.T
assert expr.rewrite(Sum).diff(X[m, n]).doit().dummy_eq((A.T * B.T)[m, n])
# Cookbook example 102:
expr = Trace(A * X.T * B)
assert expr.diff(X) == B * A
# Cookbook example 103:
expr = Trace(X.T * A)
assert expr.diff(X) == A
# Cookbook example 104:
expr = Trace(A * X.T)
assert expr.diff(X) == A
# Cookbook example 105:
# TODO: TensorProduct is not supported
#expr = Trace(TensorProduct(A, X))
#assert expr.diff(X) == Trace(A)*Identity(k)
## Second order:
# Cookbook example 106:
expr = Trace(X**2)
assert expr.diff(X) == 2 * X.T
# Cookbook example 107:
expr = Trace(X**2 * B)
assert expr.diff(X) == (X * B + B * X).T
expr = Trace(MatMul(X, X, B))
assert expr.diff(X) == (X * B + B * X).T
# Cookbook example 108:
expr = Trace(X.T * B * X)
assert expr.diff(X) == B * X + B.T * X
# Cookbook example 109:
expr = Trace(B * X * X.T)
assert expr.diff(X) == B * X + B.T * X
# Cookbook example 110:
expr = Trace(X * X.T * B)
assert expr.diff(X) == B * X + B.T * X
# Cookbook example 111:
expr = Trace(X * B * X.T)
assert expr.diff(X) == X * B.T + X * B
# Cookbook example 112:
expr = Trace(B * X.T * X)
assert expr.diff(X) == X * B.T + X * B
# Cookbook example 113:
expr = Trace(X.T * X * B)
assert expr.diff(X) == X * B.T + X * B
# Cookbook example 114:
expr = Trace(A * X * B * X)
assert expr.diff(X) == A.T * X.T * B.T + B.T * X.T * A.T
# Cookbook example 115:
expr = Trace(X.T * X)
assert expr.diff(X) == 2 * X
expr = Trace(X * X.T)
assert expr.diff(X) == 2 * X
# Cookbook example 116:
expr = Trace(B.T * X.T * C * X * B)
assert expr.diff(X) == C.T * X * B * B.T + C * X * B * B.T
# Cookbook example 117:
expr = Trace(X.T * B * X * C)
assert expr.diff(X) == B * X * C + B.T * X * C.T
# Cookbook example 118:
expr = Trace(A * X * B * X.T * C)
assert expr.diff(X) == A.T * C.T * X * B.T + C * A * X * B
# Cookbook example 119:
expr = Trace((A * X * B + C) * (A * X * B + C).T)
assert expr.diff(X) == 2 * A.T * (A * X * B + C) * B.T
# Cookbook example 120:
# TODO: no support for TensorProduct.
# expr = Trace(TensorProduct(X, X))
# expr = Trace(X)*Trace(X)
# expr.diff(X) == 2*Trace(X)*Identity(k)
# Higher Order
# Cookbook example 121:
expr = Trace(X**k)
#assert expr.diff(X) == k*(X**(k-1)).T
# Cookbook example 122:
expr = Trace(A * X**k)
#assert expr.diff(X) == # Needs indices
# Cookbook example 123:
expr = Trace(B.T * X.T * C * X * X.T * C * X * B)
assert expr.diff(
X
) == C * X * X.T * C * X * B * B.T + C.T * X * B * B.T * X.T * C.T * X + C * X * B * B.T * X.T * C * X + C.T * X * X.T * C.T * X * B * B.T
# Other
# Cookbook example 124:
expr = Trace(A * X**(-1) * B)
assert expr.diff(X) == -Inverse(X).T * A.T * B.T * Inverse(X).T
# Cookbook example 125:
expr = Trace(Inverse(X.T * C * X) * A)
# Warning: result in the cookbook is equivalent if B and C are symmetric:
assert expr.diff(X) == -X.inv().T * A.T * X.inv() * C.inv().T * X.inv(
).T - X.inv().T * A * X.inv() * C.inv() * X.inv().T
# Cookbook example 126:
expr = Trace((X.T * C * X).inv() * (X.T * B * X))
assert expr.diff(X) == -2 * C * X * (X.T * C * X).inv() * X.T * B * X * (
X.T * C * X).inv() + 2 * B * X * (X.T * C * X).inv()
# Cookbook example 127:
expr = Trace((A + X.T * C * X).inv() * (X.T * B * X))
# Warning: result in the cookbook is equivalent if B and C are symmetric:
assert expr.diff(X) == B * X * Inverse(A + X.T * C * X) - C * X * Inverse(
A + X.T * C *
X) * X.T * B * X * Inverse(A + X.T * C * X) - C.T * X * Inverse(
A.T + (C * X).T * X) * X.T * B.T * X * Inverse(
A.T + (C * X).T * X) + B.T * X * Inverse(A.T + (C * X).T * X)
def _eval_inverse(self):
try:
return MatMul(*[arg.inverse() for arg in self.args[::-1]]).doit()
except ShapeError:
from sympy.matrices.expressions.inverse import Inverse
return Inverse(self)
def test_arrayexpr_convert_matrix_to_array():
expr = M * N
result = ArrayContraction(ArrayTensorProduct(M, N), (1, 2))
assert convert_matrix_to_array(expr) == result
expr = M * N * M
result = _array_contraction(ArrayTensorProduct(M, N, M), (1, 2), (3, 4))
assert convert_matrix_to_array(expr) == result
expr = Transpose(M)
assert convert_matrix_to_array(expr) == PermuteDims(M, [1, 0])
expr = M * Transpose(N)
assert convert_matrix_to_array(expr) == _array_contraction(
_array_tensor_product(M, PermuteDims(N, [1, 0])), (1, 2))
expr = 3 * M * N
res = convert_matrix_to_array(expr)
rexpr = convert_array_to_matrix(res)
assert expr == rexpr
expr = 3 * M + N * M.T * M + 4 * k * N
res = convert_matrix_to_array(expr)
rexpr = convert_array_to_matrix(res)
assert expr == rexpr
expr = Inverse(M) * N
rexpr = convert_array_to_matrix(convert_matrix_to_array(expr))
assert expr == rexpr
expr = M**2
rexpr = convert_array_to_matrix(convert_matrix_to_array(expr))
assert expr == rexpr
expr = M * (2 * N + 3 * M)
res = convert_matrix_to_array(expr)
rexpr = convert_array_to_matrix(res)
assert expr == rexpr
expr = Trace(M)
result = ArrayContraction(M, (0, 1))
assert convert_matrix_to_array(expr) == result
expr = 3 * Trace(M)
result = ArrayContraction(ArrayTensorProduct(3, M), (0, 1))
assert convert_matrix_to_array(expr) == result
expr = 3 * Trace(Trace(M) * M)
result = ArrayContraction(ArrayTensorProduct(3, M, M), (0, 1), (2, 3))
assert convert_matrix_to_array(expr) == result
expr = 3 * Trace(M)**2
result = ArrayContraction(ArrayTensorProduct(3, M, M), (0, 1), (2, 3))
assert convert_matrix_to_array(expr) == result
expr = HadamardProduct(M, N)
result = ArrayDiagonal(ArrayTensorProduct(M, N), (0, 2), (1, 3))
assert convert_matrix_to_array(expr) == result
expr = HadamardProduct(M * N, N * M)
result = ArrayDiagonal(
ArrayContraction(ArrayTensorProduct(M, N, N, M), (1, 2), (5, 6)),
(0, 2), (1, 3))
assert convert_matrix_to_array(expr) == result
expr = HadamardPower(M, 2)
result = ArrayDiagonal(ArrayTensorProduct(M, M), (0, 2), (1, 3))
assert convert_matrix_to_array(expr) == result
expr = HadamardPower(M * N, 2)
result = ArrayDiagonal(
ArrayContraction(ArrayTensorProduct(M, N, M, N), (1, 2), (5, 6)),
(0, 2), (1, 3))
assert convert_matrix_to_array(expr) == result
expr = HadamardPower(M, n)
d0 = Dummy("d0")
result = ArrayElementwiseApplyFunc(Lambda(d0, d0**n), M)
assert convert_matrix_to_array(expr).dummy_eq(result)
expr = M**2
assert isinstance(expr, MatPow)
assert convert_matrix_to_array(expr) == ArrayContraction(
ArrayTensorProduct(M, M), (1, 2))
expr = a.T * b
cg = convert_matrix_to_array(expr)
assert cg == ArrayContraction(ArrayTensorProduct(a, b), (0, 2))
