def validate(*args):
if not all(arg.is_Matrix for arg in args):
raise TypeError("Mix of Matrix and Scalar symbols")
A = args[0]
for B in args[1:]:
if A.shape != B.shape:
raise ShapeError("Matrices %s and %s are not aligned"%(A, B))
def __new__(cls, mat, **kwargs):
if not mat.is_Matrix:
return mat**(-1)
try:
return mat.eval_inverse(**kwargs)
except (AttributeError, NotImplementedError):
pass
if hasattr(mat, 'inv'):
return mat.inv()
if mat.is_Inverse:
return mat.arg
if mat.is_Identity:
return mat
if not mat.is_square:
raise ShapeError("Inverse of non-square matrix %s" % mat)
if mat.is_Mul:
try:
return MatMul(*[Inverse(arg) for arg in mat.args[::-1]])
except ShapeError:
pass
return MatPow.__new__(cls, mat, -1)
def __new__(cls, *args):
args = map(matrixify, args)
args = [arg for arg in args if arg!=0]
if not all(arg.is_Matrix for arg in args):
raise ValueError("Mix of Matrix and Scalar symbols")
# Check that the shape of the args is consistent
A = args[0]
for B in args[1:]:
if A.shape != B.shape:
raise ShapeError("Matrices %s and %s are not aligned"%(A,B))
expr = Add.__new__(cls, *args)
if expr == S.Zero:
return ZeroMatrix(*args[0].shape)
expr = matrixify(expr)
if expr.is_Mul:
return MatMul(*expr.args)
# Clear out Identities
# Any zeros around?
if expr.is_Add and any(M.is_ZeroMatrix for M in expr.args):
newargs = [M for M in expr.args if not M.is_ZeroMatrix] # clear out
if len(newargs)==0: # Did we lose everything?
return ZeroMatrix(*args[0].shape)
if expr.args != newargs: # Removed some 0's but not everything?
return MatAdd(*newargs) # Repeat with simpler expr
return expr
def __new__(cls, mat):
if not mat.is_Matrix:
raise TypeError("Input to Determinant, %s, not a matrix" %
str(mat))
if not mat.is_square:
raise ShapeError("Det of a non-square matrix")
return Basic.__new__(cls, mat)
def __new__(cls, b, e):
e = _sympify(e)
if e is S.One or b.is_ZeroMatrix:
return b
elif not b.is_square:
raise ShapeError("Power of non-square matrix %s"%b)
elif e is S.Zero:
return Identity(b.n)
else:
return MatrixExpr.__new__(cls, b, e)
def __new__(cls, mat):
if not mat.is_Matrix:
raise TypeError("input to Trace, %s, is not a matrix" % str(mat))
if not mat.is_square:
raise ShapeError("Trace of a non-square matrix")
try:
return mat._eval_trace()
except (AttributeError, NotImplementedError):
return Basic.__new__(cls, mat)
def __new__(cls, mat, **kwargs):
if not mat.is_Matrix:
return mat**(-1)
if not mat.is_square:
raise ShapeError("Inverse of non-square matrix %s" % mat)
try:
return mat._eval_inverse(**kwargs)
except (AttributeError, NotImplementedError):
return MatPow.__new__(cls, mat, -1)
def __new__(cls, *args):
# Check that the shape of the args is consistent
matrices = [arg for arg in args if arg.is_Matrix]
for i in range(len(matrices) - 1):
A, B = matrices[i:i + 2]
if A.cols != B.rows:
raise ShapeError("Matrices %s and %s are not aligned" % (A, B))
if any(arg.is_zero for arg in args):
return ZeroMatrix(matrices[0].rows, matrices[-1].cols)
expr = matrixify(Mul.__new__(cls, *args))
if expr.is_Add:
return MatAdd(*expr.args)
if expr.is_Pow:
assert expr.exp.is_Integer
expr = Basic.__new__(MatMul, *[expr.base for i in range(expr.exp)])
if not expr.is_Mul:
return expr
if any(arg.is_Matrix and arg.is_ZeroMatrix for arg in expr.args):
return ZeroMatrix(*expr.shape)
# Clear out Identities
nonmats = [M for M in expr.args if not M.is_Matrix] # scalars
mats = [M for M in expr.args if M.is_Matrix] # matrices
if any(M.is_Identity for M in mats): # Any identities around?
newmats = [M for M in mats if not M.is_Identity] # clear out
if len(newmats) == 0: # Did we lose everything?
newmats = [Identity(expr.rows)] # put just one back in
if mats != newmats: # Removed some I's but not everything?
return MatMul(*(nonmats + newmats)) # Repeat with simpler expr
return expr
def validate(*matrices):
""" Checks for valid shapes for args of MatMul """
for i in range(len(matrices) - 1):
A, B = matrices[i:i + 2]
if A.cols != B.rows:
raise ShapeError("Matrices %s and %s are not aligned" % (A, B))