106 lines
2.6 KiB
Python
106 lines
2.6 KiB
Python
from sympy.core.basic import Basic
|
|
from sympy.functions import adjoint, conjugate
|
|
|
|
from sympy.matrices.expressions.matexpr import MatrixExpr
|
|
|
|
|
|
class Transpose(MatrixExpr):
|
|
"""
|
|
The transpose of a matrix expression.
|
|
|
|
This is a symbolic object that simply stores its argument without
|
|
evaluating it. To actually compute the transpose, use the ``transpose()``
|
|
function, or the ``.T`` attribute of matrices.
|
|
|
|
Examples
|
|
========
|
|
|
|
>>> from sympy import MatrixSymbol, Transpose, transpose
|
|
>>> A = MatrixSymbol('A', 3, 5)
|
|
>>> B = MatrixSymbol('B', 5, 3)
|
|
>>> Transpose(A)
|
|
A.T
|
|
>>> A.T == transpose(A) == Transpose(A)
|
|
True
|
|
>>> Transpose(A*B)
|
|
(A*B).T
|
|
>>> transpose(A*B)
|
|
B.T*A.T
|
|
|
|
"""
|
|
is_Transpose = True
|
|
|
|
def doit(self, **hints):
|
|
arg = self.arg
|
|
if hints.get('deep', True) and isinstance(arg, Basic):
|
|
arg = arg.doit(**hints)
|
|
_eval_transpose = getattr(arg, '_eval_transpose', None)
|
|
if _eval_transpose is not None:
|
|
result = _eval_transpose()
|
|
return result if result is not None else Transpose(arg)
|
|
else:
|
|
return Transpose(arg)
|
|
|
|
@property
|
|
def arg(self):
|
|
return self.args[0]
|
|
|
|
@property
|
|
def shape(self):
|
|
return self.arg.shape[::-1]
|
|
|
|
def _entry(self, i, j, expand=False, **kwargs):
|
|
return self.arg._entry(j, i, expand=expand, **kwargs)
|
|
|
|
def _eval_adjoint(self):
|
|
return conjugate(self.arg)
|
|
|
|
def _eval_conjugate(self):
|
|
return adjoint(self.arg)
|
|
|
|
def _eval_transpose(self):
|
|
return self.arg
|
|
|
|
def _eval_trace(self):
|
|
from .trace import Trace
|
|
return Trace(self.arg) # Trace(X.T) => Trace(X)
|
|
|
|
def _eval_determinant(self):
|
|
from sympy.matrices.expressions.determinant import det
|
|
return det(self.arg)
|
|
|
|
def _eval_derivative(self, x):
|
|
# x is a scalar:
|
|
return self.arg._eval_derivative(x)
|
|
|
|
def _eval_derivative_matrix_lines(self, x):
|
|
lines = self.args[0]._eval_derivative_matrix_lines(x)
|
|
return [i.transpose() for i in lines]
|
|
|
|
|
|
def transpose(expr):
|
|
"""Matrix transpose"""
|
|
return Transpose(expr).doit(deep=False)
|
|
|
|
|
|
from sympy.assumptions.ask import ask, Q
|
|
from sympy.assumptions.refine import handlers_dict
|
|
|
|
|
|
def refine_Transpose(expr, assumptions):
|
|
"""
|
|
>>> from sympy import MatrixSymbol, Q, assuming, refine
|
|
>>> X = MatrixSymbol('X', 2, 2)
|
|
>>> X.T
|
|
X.T
|
|
>>> with assuming(Q.symmetric(X)):
|
|
... print(refine(X.T))
|
|
X
|
|
"""
|
|
if ask(Q.symmetric(expr), assumptions):
|
|
return expr.arg
|
|
|
|
return expr
|
|
|
|
handlers_dict['Transpose'] = refine_Transpose
|