Merge pull request #1676 from jrioux/printing

Matrice printing issues

Latex and pretty printing of Adjoint, MatAdd, MatPow, and Transpose.

Fixes issues 3485 and 3486.
http://code.google.com/p/sympy/issues/detail?id=3485
http://code.google.com/p/sympy/issues/detail?id=3486

sympy/printing/latex.py

@@ -137,9 +137,9 @@ def _print_Add(self, expr, order=None):
 
         for term in terms[1:]:
             if not _coeff_isneg(term):
-                tex += " +"
-
-            tex += " " + self._print(term)
+                tex += " + " + self._print(term)
+            else:
+                tex += " - " + self._print(-term)
 
         return tex
 
@@ -1015,29 +1015,23 @@ def _print_BlockMatrix(self, expr):
 
     def _print_Transpose(self, expr):
         mat = expr.arg
-        if mat.is_MatAdd or mat.is_MatMul:
+        from sympy.matrices import MatrixSymbol
+        if not isinstance(mat, MatrixSymbol):
             return r"\left(%s\right)^T" % self._print(mat)
         else:
             return "%s^T" % self._print(mat)
 
     def _print_Adjoint(self, expr):
         mat = expr.arg
-        if mat.is_MatAdd or mat.is_MatMul:
+        from sympy.matrices import MatrixSymbol
+        if not isinstance(mat, MatrixSymbol):
             return r"\left(%s\right)^\dag" % self._print(mat)
         else:
             return "%s^\dag" % self._print(mat)
 
     def _print_MatAdd(self, expr):
-        # Stolen from print_Add
         terms = list(expr.args)
-        tex = self._print(terms[0])
-
-        for term in terms[1:]:
-            if not _coeff_isneg(term):
-                tex += " +"
-
-            tex += " " + self._print(term)
-
+        tex = " + ".join(map(self._print, terms))
         return tex
 
     def _print_MatMul(self, expr):
@@ -1060,7 +1054,8 @@ def parens(x):
 
     def _print_MatPow(self, expr):
         base, exp = expr.base, expr.exp
-        if base.is_Add or base.is_Mul:
+        from sympy.matrices import MatrixSymbol
+        if not isinstance(base, MatrixSymbol):
             return r"\left(%s\right)^{%s}" % (self._print(base), self._print(exp))
         else:
             return "%s^{%s}" % (self._print(base), self._print(exp))

sympy/printing/pretty/pretty.py

@@ -608,36 +608,34 @@ def _print_MatrixBase(self, e):
     _print_ImmutableMatrix = _print_MatrixBase
     _print_Matrix = _print_MatrixBase
 
-    def _print_Transpose(self, T):
-        pform = self._print(T.arg)
-        if (T.arg.is_MatAdd or T.arg.is_MatMul):
+    def _print_Transpose(self, expr):
+        pform = self._print(expr.arg)
+        from sympy.matrices import MatrixSymbol
+        if not isinstance(expr.arg, MatrixSymbol):
             pform = prettyForm(*pform.parens())
-        pform = prettyForm(*pform.right("'"))
+        pform = pform**(prettyForm('T'))
         return pform
 
-    def _print_Adjoint(self, A):
-        pform = self._print(A.arg)
+    def _print_Adjoint(self, expr):
+        pform = self._print(expr.arg)
         if self._use_unicode:
             dag = prettyForm(u'\u2020')
         else:
             dag = prettyForm('+')
-        if (A.arg.is_MatAdd or A.arg.is_MatMul):
+        from sympy.matrices import MatrixSymbol
+        if not isinstance(expr.arg, MatrixSymbol):
             pform = prettyForm(*pform.parens())
-        pform = pform**prettyForm(u'\u2020')
-        return pform
-
-    def _print_Inverse(self, I):
-        pform = self._print(I.arg)
-        if (I.arg.is_Add or I.arg.is_Mul or I.arg.is_Pow):
-            pform = prettyForm(*pform.parens())
-        pform = prettyForm(*pform.right("^-1"))
+        pform = pform**dag
         return pform
 
     def _print_BlockMatrix(self, B):
         if B.blocks.shape == (1, 1):
             return self._print(B.blocks[0, 0])
         return self._print(B.blocks)
 
+    def _print_MatAdd(self, expr):
+        return self._print_seq(expr.args, None, None, ' + ')
+
     def _print_MatMul(self, expr):
         args = list(expr.args)
         from sympy import Add, MatAdd, HadamardProduct
@@ -650,8 +648,13 @@ def _print_MatMul(self, expr):
 
         return prettyForm.__mul__(*args)
 
-    def _print_MatAdd(self, expr):
-        return self._print_seq(expr.args, None, None, ' + ')
+    def _print_MatPow(self, expr):
+        pform = self._print(expr.base)
+        from sympy.matrices import MatrixSymbol
+        if not isinstance(expr.base, MatrixSymbol):
+            pform = prettyForm(*pform.parens())
+        pform = pform**(self._print(expr.exp))
+        return pform
 
     def _print_HadamardProduct(self, expr):
         from sympy import MatAdd, MatMul

sympy/printing/pretty/tests/test_pretty.py

@@ -2164,6 +2164,40 @@ def test_pretty_matrix():
     assert upretty(expr) == ucode_str
 
 
+def test_Adjoint():
+    from sympy.matrices import Adjoint, Inverse, MatrixSymbol, Transpose
+    X = MatrixSymbol('X', 2, 2)
+    Y = MatrixSymbol('Y', 2, 2)
+    assert pretty(Adjoint(X)) == " +\nX "
+    assert pretty(Adjoint(X + Y)) == "       +\n(X + Y) "
+    assert pretty(Adjoint(X) + Adjoint(Y)) == " +    +\nX  + Y "
+    assert pretty(Adjoint(X*Y)) == "     +\n(X*Y) "
+    assert pretty(Adjoint(Y)*Adjoint(X)) == " +  +\nY *X "
+    assert pretty(Adjoint(X**2)) == "    +\n/ 2\\ \n\\X / "
+    assert pretty(Adjoint(X)**2) == "    2\n/ +\\ \n\\X / "
+    assert pretty(Adjoint(Inverse(X))) == "     +\n/ -1\\ \n\\X  / "
+    assert pretty(Inverse(Adjoint(X))) == "    -1\n/ +\\  \n\\X /  "
+    assert pretty(Adjoint(Transpose(X))) == "    +\n/ T\\ \n\\X / "
+    assert pretty(Transpose(Adjoint(X))) == "    T\n/ +\\ \n\\X / "
+    assert upretty(Adjoint(X)) == u" \u2020\nX "
+    assert upretty(Adjoint(X + Y)) == u"       \u2020\n(X + Y) "
+    assert upretty(Adjoint(X) + Adjoint(Y)) == u" \u2020    \u2020\nX  + Y "
+    assert upretty(Adjoint(X*Y)) == u"     \u2020\n(X\u22c5Y) "
+    assert upretty(Adjoint(Y)*Adjoint(X)) == u" \u2020  \u2020\nY \u22c5X "
+    assert upretty(Adjoint(X**2)) == \
+        u"    \u2020\n\u239b 2\u239e \n\u239dX \u23a0 "
+    assert upretty(Adjoint(X)**2) == \
+        u"    2\n\u239b \u2020\u239e \n\u239dX \u23a0 "
+    assert upretty(Adjoint(Inverse(X))) == \
+        u"     \u2020\n\u239b -1\u239e \n\u239dX  \u23a0 "
+    assert upretty(Inverse(Adjoint(X))) == \
+        u"    -1\n\u239b \u2020\u239e  \n\u239dX \u23a0  "
+    assert upretty(Adjoint(Transpose(X))) == \
+        u"    \u2020\n\u239b T\u239e \n\u239dX \u23a0 "
+    assert upretty(Transpose(Adjoint(X))) == \
+        u"    T\n\u239b \u2020\u239e \n\u239dX \u23a0 "
+
+
 def test_pretty_piecewise():
     expr = Piecewise((x, x < 1), (x**2, True))
     ascii_str = \

sympy/printing/tests/test_latex.py

@@ -487,15 +487,15 @@ def test_latex_Piecewise():
 
 def test_latex_Matrix():
     M = Matrix([[1 + x, y], [y, x - 1]])
-    assert latex(M) == '\\left[\\begin{smallmatrix}x + 1 & y\\\\y & x -' \
-                       '1\\end{smallmatrix}\\right]'
+    assert latex(M) == '\\left[\\begin{smallmatrix}x + 1 & y\\\\y & x - 1' \
+                       '\\end{smallmatrix}\\right]'
     settings = {'mat_str': 'bmatrix'}
     assert latex(M, **settings) == '\\left[\\begin{bmatrix}x + 1 & y\\\\y &' \
-        ' x -1\\end{bmatrix}\\right]'
+        ' x - 1\\end{bmatrix}\\right]'
     settings['mat_delim'] = None
-    assert latex(M, **settings) == '\\begin{bmatrix}x + 1 & y\\\\y & x -1' \
+    assert latex(M, **settings) == '\\begin{bmatrix}x + 1 & y\\\\y & x - 1' \
         '\\end{bmatrix}'
-    assert latex(M) == '\\left[\\begin{smallmatrix}x + 1 & y\\\\y & x -1' \
+    assert latex(M) == '\\left[\\begin{smallmatrix}x + 1 & y\\\\y & x - 1' \
                        '\\end{smallmatrix}\\right]'
 
 
@@ -797,11 +797,20 @@ def test_Tr():
 
 
 def test_Adjoint():
-    from sympy.matrices import MatrixSymbol, Adjoint
+    from sympy.matrices import MatrixSymbol, Adjoint, Inverse, Transpose
     X = MatrixSymbol('X', 2, 2)
     Y = MatrixSymbol('Y', 2, 2)
+    assert latex(Adjoint(X)) == r'X^\dag'
     assert latex(Adjoint(X + Y)) == r'\left(X + Y\right)^\dag'
     assert latex(Adjoint(X) + Adjoint(Y)) == r'X^\dag + Y^\dag'
+    assert latex(Adjoint(X*Y)) == r'\left(X Y\right)^\dag'
+    assert latex(Adjoint(Y)*Adjoint(X)) == r'Y^\dag X^\dag'
+    assert latex(Adjoint(X**2)) == r'\left(X^{2}\right)^\dag'
+    assert latex(Adjoint(X)**2) == r'\left(X^\dag\right)^{2}'
+    assert latex(Adjoint(Inverse(X))) == r'\left(X^{-1}\right)^\dag'
+    assert latex(Inverse(Adjoint(X))) == r'\left(X^\dag\right)^{-1}'
+    assert latex(Adjoint(Transpose(X))) == r'\left(X^T\right)^\dag'
+    assert latex(Transpose(Adjoint(X))) == r'\left(X^\dag\right)^T'
 
 
 def test_Hadamard():