Source code for sympy.matrices.expressions.transpose

from __future__ import print_function, division

from sympy import Basic

from sympy.matrices.expressions.matexpr import MatrixExpr

[docs]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.matrices import MatrixSymbol, Transpose
>>> from sympy.functions import 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)
try:
result = arg._eval_transpose()
return result if result is not None else Transpose(arg)
except AttributeError:
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):
return self.arg._entry(j, i, expand=expand)

return conjugate(self.arg)

def _eval_conjugate(self):

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 transpose(expr):
""" Matrix transpose """
return Transpose(expr).doit()

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
"""