Repository: sympy/sympy

Issue:
Error when building docs: py:class reference target not found: mpz
I get this error when building the docs

```
<unknown>:1: WARNING: py:class reference target not found: mpz
<unknown>:1: WARNING: py:class reference target not found: mpz
<unknown>:1: WARNING: py:class reference target not found: mpq
<unknown>:1: WARNING: py:class reference target not found: mpq
```

This is with the latest version of Sphinx. I have gmpy2 installed. 

Discussion:

Patch:
diff --git a/doc/src/modules/physics/control/lti.rst b/doc/src/modules/physics/control/lti.rst
index c10b5103af..4d683a4ffa 100644
--- a/doc/src/modules/physics/control/lti.rst
+++ b/doc/src/modules/physics/control/lti.rst
@@ -18,6 +18,3 @@ lti
 
 .. autoclass:: Feedback
    :members:
-
-.. autoclass:: TransferFunctionMatrix
-   :members:
\ No newline at end of file
diff --git a/doc/src/modules/polys/domainsref.rst b/doc/src/modules/polys/domainsref.rst
index feb111c2a1..08afc52e00 100644
--- a/doc/src/modules/polys/domainsref.rst
+++ b/doc/src/modules/polys/domainsref.rst
@@ -131,6 +131,7 @@ when available.
 .. autoclass:: PythonIntegerRing
 .. autoclass:: GMPYIntegerRing
    :members:
+   :exclude-members: dtype, tp
 
 .. _QQ:
 
@@ -186,6 +187,7 @@ preferred because it is significantly faster.
 .. autoclass:: PythonRationalField
 .. autoclass:: GMPYRationalField
    :members:
+   :exclude-members: dtype, tp
 
 .. autoclass:: sympy.external.pythonmpq.PythonMPQ
 
diff --git a/sympy/physics/control/__init__.py b/sympy/physics/control/__init__.py
index faa8400da4..7b4c7825c7 100644
--- a/sympy/physics/control/__init__.py
+++ b/sympy/physics/control/__init__.py
@@ -1,3 +1,3 @@
-from .lti import TransferFunction, Series, Parallel, Feedback, TransferFunctionMatrix
+from .lti import TransferFunction, Series, Parallel, Feedback
 
-__all__ = ['TransferFunction', 'Series', 'Parallel', 'Feedback', 'TransferFunctionMatrix']
+__all__ = ['TransferFunction', 'Series', 'Parallel', 'Feedback']
diff --git a/sympy/physics/control/lti.py b/sympy/physics/control/lti.py
index f28bb02047..c28371e242 100644
--- a/sympy/physics/control/lti.py
+++ b/sympy/physics/control/lti.py
@@ -1,14 +1,12 @@
-from sympy import Basic, Add, Mul, Pow, degree, Symbol, expand, cancel, Expr, roots
-from sympy.core.containers import Tuple
+from sympy import Basic, Mul, Pow, degree, Symbol, expand, cancel, Expr, roots
 from sympy.core.evalf import EvalfMixin
 from sympy.core.logic import fuzzy_and
 from sympy.core.numbers import Integer, ComplexInfinity
 from sympy.core.sympify import sympify, _sympify
 from sympy.polys import Poly, rootof
 from sympy.series import limit
-from sympy.matrices import ImmutableMatrix
 
-__all__ = ['TransferFunction', 'Series', 'Parallel', 'Feedback', 'TransferFunctionMatrix']
+__all__ = ['TransferFunction', 'Series', 'Parallel', 'Feedback']
 
 
 def _roots(poly, var):
@@ -484,9 +482,9 @@ def is_stable(self):
         ========
 
         >>> from sympy.abc import s, p, a
-        >>> from sympy import symbols
-        >>> from sympy.physics.control.lti import TransferFunction
+        >>> from sympy.core.symbol import symbols
         >>> q, r = symbols('q, r', negative=True)
+        >>> from sympy.physics.control.lti import TransferFunction
         >>> tf1 = TransferFunction((1 - s)**2, (s + 1)**2, s)
         >>> tf1.is_stable()
         True
@@ -676,7 +674,7 @@ def to_expr(self):
 
         >>> from sympy.abc import s, p, a, b
         >>> from sympy.physics.control.lti import TransferFunction
-        >>> from sympy import Expr
+        >>> from sympy.core.expr import Expr
         >>> tf1 = TransferFunction(s, a*s**2 + 1, s)
         >>> tf1.to_expr()
         s/(a*s**2 + 1)
@@ -691,10 +689,7 @@ def to_expr(self):
 
         """
 
-        if self.num != 1:
-            return Mul(self.num, Pow(self.den, -1, evaluate=False), evaluate=False)
-        else:
-            return Pow(self.den, -1, evaluate=False)
+        return Mul(self.num, Pow(self.den, -1, evaluate=False), evaluate=False)
 
 
 class Series(Basic):
@@ -896,10 +891,6 @@ def __truediv__(self, other):
     def __neg__(self):
         return Series(TransferFunction(-1, 1, self.var), self)
 
-    def to_expr(self):
-        """Returns the equivalent ``Expr`` object."""
-        return Mul(*(arg.to_expr() for arg in self.args), evaluate=False)
-
     @property
     def is_proper(self):
         """
@@ -1155,10 +1146,6 @@ def __mul__(self, other):
     def __neg__(self):
         return Series(TransferFunction(-1, 1, self.var), self)
 
-    def to_expr(self):
-        """Returns the equivalent ``Expr`` object."""
-        return Add(*(arg.to_expr() for arg in self.args), evaluate=False)
-
     @property
     def is_proper(self):
         """
@@ -1435,509 +1422,3 @@ def _eval_rewrite_as_TransferFunction(self, num, den, **kwargs):
 
     def __neg__(self):
         return Feedback(-self.num, self.den)
-
-
-def _to_TFM(mat, var):
-    """Private method to convert ImmutableMatrix to TransferFunctionMatrix efficiently"""
-    to_tf = lambda expr: TransferFunction.from_rational_expression(expr, var)
-    arg = [[to_tf(expr) for expr in row] for row in mat.tolist()]
-    return TransferFunctionMatrix(arg)
-
-
-class TransferFunctionMatrix(Basic):
-    r"""
-    A class for representing the MIMO (multiple-input and multiple-output)
-    generalization of the SISO (single-input and single-output) transfer function.
-
-    It is a matrix of transfer functions (``TransferFunction``, SISO-``Series`` or SISO-``Parallel``).
-    There is only one argument, ``arg`` which is also the compulsory argument.
-    ``arg`` is expected to be strictly of the type list of lists
-    which holds the transfer functions or reducible to transfer functions.
-
-    Parameters
-    ==========
-
-    arg: Nested ``List`` (strictly).
-        Users are expected to input a nested list of ``TransferFunction``, ``Series``
-        and/or ``Parallel`` objects.
-
-    Examples
-    ========
-
-    ``pprint()`` can be used for better visualization of ``TransferFunctionMatrix`` objects.
-
-    >>> from sympy.abc import s, p, a
-    >>> from sympy import pprint
-    >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel
-    >>> tf_1 = TransferFunction(s + a, s**2 + s + 1, s)
-    >>> tf_2 = TransferFunction(p**4 - 3*p + 2, s + p, s)
-    >>> tf_3 = TransferFunction(3, s + 2, s)
-    >>> tf_4 = TransferFunction(-a + p, 9*s - 9, s)
-    >>> tfm_1 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_3]])
-    >>> tfm_1
-    TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)))
-    >>> tfm_1.var
-    s
-    >>> tfm_1.num_inputs
-    1
-    >>> tfm_1.num_outputs
-    3
-    >>> tfm_1.shape
-    (3, 1)
-    >>> tfm_1.args
-    (((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)),)
-    >>> tfm_2 = TransferFunctionMatrix([[tf_1, -tf_3], [tf_2, -tf_1], [tf_3, -tf_2]])
-    >>> tfm_2
-    TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-p**4 + 3*p - 2, p + s, s))))
-    >>> pprint(tfm_2, use_unicode=False)  # pretty-printing for better visualization
-    [   a + s           -3       ]
-    [ ----------       -----     ]
-    [  2               s + 2     ]
-    [ s  + s + 1                 ]
-    [                            ]
-    [ 4                          ]
-    [p  - 3*p + 2      -a - s    ]
-    [------------    ----------  ]
-    [   p + s         2          ]
-    [                s  + s + 1  ]
-    [                            ]
-    [                 4          ]
-    [     3        - p  + 3*p - 2]
-    [   -----      --------------]
-    [   s + 2          p + s     ]{t}
-
-    TransferFunctionMatrix can be transposed, if user wants to switch the input and output transfer functions
-
-    >>> tfm_2.transpose()
-    TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(3, s + 2, s)), (TransferFunction(-3, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s))))
-    >>> pprint(_, use_unicode=False)
-    [             4                          ]
-    [  a + s     p  - 3*p + 2        3       ]
-    [----------  ------------      -----     ]
-    [ 2             p + s          s + 2     ]
-    [s  + s + 1                              ]
-    [                                        ]
-    [                             4          ]
-    [   -3          -a - s     - p  + 3*p - 2]
-    [  -----      ----------   --------------]
-    [  s + 2       2               p + s     ]
-    [             s  + s + 1                 ]{t}
-
-    >>> tf_5 = TransferFunction(5, s, s)
-    >>> tf_6 = TransferFunction(5*s, (2 + s**2), s)
-    >>> tf_7 = TransferFunction(5, (s*(2 + s**2)), s)
-    >>> tf_8 = TransferFunction(5, 1, s)
-    >>> tfm_3 = TransferFunctionMatrix([[tf_5, tf_6], [tf_7, tf_8]])
-    >>> tfm_3
-    TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))))
-    >>> pprint(tfm_3, use_unicode=False)
-    [    5        5*s  ]
-    [    -       ------]
-    [    s        2    ]
-    [            s  + 2]
-    [                  ]
-    [    5         5   ]
-    [----------    -   ]
-    [  / 2    \    1   ]
-    [s*\s  + 2/        ]{t}
-    >>> tfm_3.var
-    s
-    >>> tfm_3.shape
-    (2, 2)
-    >>> tfm_3.num_outputs
-    2
-    >>> tfm_3.num_inputs
-    2
-    >>> tfm_3.args
-    (((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))),)
-
-    To access the ``TransferFunction`` at any index in the ``TransferFunctionMatrix``, use the index notation.
-
-    >>> tfm_3[1, 0]  # gives the TransferFunction present at 2nd Row and 1st Col. Similar to that in Matrix classes
-    TransferFunction(5, s*(s**2 + 2), s)
-    >>> tfm_3[0, 0]  # gives the TransferFunction present at 1st Row and 1st Col.
-    TransferFunction(5, s, s)
-    >>> tfm_3[:, 0]  # gives the first column
-    TransferFunctionMatrix(((TransferFunction(5, s, s),), (TransferFunction(5, s*(s**2 + 2), s),)))
-    >>> pprint(_, use_unicode=False)
-    [    5     ]
-    [    -     ]
-    [    s     ]
-    [          ]
-    [    5     ]
-    [----------]
-    [  / 2    \]
-    [s*\s  + 2/]{t}
-    >>> tfm_3[0, :]  # gives the first row
-    TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)),))
-    >>> pprint(_, use_unicode=False)
-    [5   5*s  ]
-    [-  ------]
-    [s   2    ]
-    [   s  + 2]{t}
-
-    To negate a transfer function matrix, ``-`` operator can be prepended:
-
-    >>> tfm_4 = TransferFunctionMatrix([[tf_2], [-tf_1], [tf_3]])
-    >>> -tfm_4
-    TransferFunctionMatrix(((TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(-3, s + 2, s),)))
-    >>> tfm_5 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, -tf_1]])
-    >>> -tfm_5
-    TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s)), (TransferFunction(-3, s + 2, s), TransferFunction(a + s, s**2 + s + 1, s))))
-
-    ``subs()`` returns the ``TransferFunctionMatrix`` object with the value substituted in the expression. This will not
-    mutate your original ``TransferFunctionMatrix``.
-
-    >>> tfm_2.subs(p, 2)  #  substituting p everywhere in tfm_2 with 2.
-    TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s))))
-    >>> pprint(_, use_unicode=False)
-    [  a + s        -3     ]
-    [----------    -----   ]
-    [ 2            s + 2   ]
-    [s  + s + 1            ]
-    [                      ]
-    [    12        -a - s  ]
-    [  -----     ----------]
-    [  s + 2      2        ]
-    [            s  + s + 1]
-    [                      ]
-    [    3          -12    ]
-    [  -----       -----   ]
-    [  s + 2       s + 2   ]{t}
-    >>> pprint(tfm_2, use_unicode=False) # State of tfm_2 is unchanged after substitution
-    [   a + s           -3       ]
-    [ ----------       -----     ]
-    [  2               s + 2     ]
-    [ s  + s + 1                 ]
-    [                            ]
-    [ 4                          ]
-    [p  - 3*p + 2      -a - s    ]
-    [------------    ----------  ]
-    [   p + s         2          ]
-    [                s  + s + 1  ]
-    [                            ]
-    [                 4          ]
-    [     3        - p  + 3*p - 2]
-    [   -----      --------------]
-    [   s + 2          p + s     ]{t}
-
-    ``subs()`` also supports multiple substitutions.
-
-    >>> tfm_2.subs({p: 2, a: 1})  # substituting p with 2 and a with 1
-    TransferFunctionMatrix(((TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-s - 1, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s))))
-    >>> pprint(_, use_unicode=False)
-    [  s + 1        -3     ]
-    [----------    -----   ]
-    [ 2            s + 2   ]
-    [s  + s + 1            ]
-    [                      ]
-    [    12        -s - 1  ]
-    [  -----     ----------]
-    [  s + 2      2        ]
-    [            s  + s + 1]
-    [                      ]
-    [    3          -12    ]
-    [  -----       -----   ]
-    [  s + 2       s + 2   ]{t}
-
-    Users can reduce the ``Series`` and ``Parallel`` elements of the matrix to ``TransferFunction`` by using
-    ``doit()``.
-
-    >>> tfm_6 = TransferFunctionMatrix([[Series(tf_3, tf_4), Parallel(tf_3, tf_4)]])
-    >>> tfm_6
-    TransferFunctionMatrix(((Series(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s)), Parallel(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s))),))
-    >>> pprint(tfm_6, use_unicode=False)
-    [ -a + p   3     -a + p     3  ]
-    [-------*-----  ------- + -----]
-    [9*s - 9 s + 2  9*s - 9   s + 2]{t}
-    >>> tfm_6.doit()
-    TransferFunctionMatrix(((TransferFunction(-3*a + 3*p, (s + 2)*(9*s - 9), s), TransferFunction(27*s + (-a + p)*(s + 2) - 27, (s + 2)*(9*s - 9), s)),))
-    >>> pprint(_, use_unicode=False)
-    [    -3*a + 3*p     27*s + (-a + p)*(s + 2) - 27]
-    [-----------------  ----------------------------]
-    [(s + 2)*(9*s - 9)       (s + 2)*(9*s - 9)      ]{t}
-    >>> tf_9 = TransferFunction(1, s, s)
-    >>> tf_10 = TransferFunction(1, s**2, s)
-    >>> tfm_7 = TransferFunctionMatrix([[Series(tf_9, tf_10), tf_9], [tf_10, Parallel(tf_9, tf_10)]])
-    >>> tfm_7
-    TransferFunctionMatrix(((Series(TransferFunction(1, s, s), TransferFunction(1, s**2, s)), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), Parallel(TransferFunction(1, s, s), TransferFunction(1, s**2, s)))))
-    >>> pprint(tfm_7, use_unicode=False)
-    [ 1      1   ]
-    [----    -   ]
-    [   2    s   ]
-    [s*s         ]
-    [            ]
-    [ 1    1    1]
-    [ --   -- + -]
-    [  2    2   s]
-    [ s    s     ]{t}
-    >>> tfm_7.doit()
-    TransferFunctionMatrix(((TransferFunction(1, s**3, s), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), TransferFunction(s**2 + s, s**3, s))))
-    >>> pprint(_, use_unicode=False)
-    [1     1   ]
-    [--    -   ]
-    [ 3    s   ]
-    [s         ]
-    [          ]
-    [     2    ]
-    [1   s  + s]
-    [--  ------]
-    [ 2     3  ]
-    [s     s   ]{t}
-
-    See Also
-    ========
-
-    TransferFunction, Series, Parallel, Feedback
-
-    """
-    def __new__(cls, arg):
-
-        expr_mat_arg = []
-        try:
-            var = arg[0][0].var
-        except TypeError:
-            raise ValueError("`arg` param in TransferFunctionMatrix should "
-            "strictly be a nested list containing TransferFunction objects.")
-        for row_index, row in enumerate(arg):
-            temp = []
-            for col_index, element in enumerate(row):
-                if not isinstance(element, (TransferFunction, Series, Parallel)):
-                    raise TypeError("Incompatible type found as the element of "
-                    f"TransferFunctionMatrix at index {(row_index, col_index)}.")
-
-                if var != element.var:
-                    raise ValueError("Conflicting value(s) found for `var`. All TransferFunction instances in "
-                            "TransferFunctionMatrix should use the same complex variable in Laplace domain.")
-
-                temp.append(element.to_expr())
-            expr_mat_arg.append(temp)
-
-
-        if isinstance(arg, (list, Tuple)):
-            # Making nested Tuple (sympy.core.containers.Tuple) from nested list or nested python tuple
-            arg = Tuple(*(Tuple(*r, sympify=False) for r in arg), sympify=False)
-
-        obj = super(TransferFunctionMatrix, cls).__new__(cls, arg)
-        obj._expr_mat = ImmutableMatrix(expr_mat_arg)
-        return obj
-
-    @classmethod
-    def from_Matrix(cls, matrix, var):
-        """
-        Creates a new ``TransferFunctionMatrix`` efficiently from a SymPy Matrix of ``Expr`` objects.
-
-        Parameters
-        ==========
-
-        matrix : ``ImmutableMatrix`` having ``Expr``/``Number`` elements.
-        var : Symbol
-            Complex variable of the Laplace transform which will be used by the
-            all the ``TransferFunction`` objects in the ``TransferFunctionMatrix``.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import s
-        >>> from sympy.physics.control.lti import TransferFunctionMatrix
-        >>> from sympy import Matrix, pprint
-        >>> M = Matrix([[s, 1/s], [1/(s+1), s]])
-        >>> M_tf = TransferFunctionMatrix.from_Matrix(M, s)
-        >>> pprint(M_tf, use_unicode=False)
-        [  s    1]
-        [  -    -]
-        [  1    s]
-        [        ]
-        [  1    s]
-        [-----  -]
-        [s + 1  1]{t}
-        >>> M_tf.elem_poles()
-        [[[], [0]], [[-1], []]]
-        >>> M_tf.elem_zeros()
-        [[[0], []], [[], [0]]]
-
-        """
-        return _to_TFM(matrix, var)
-
-    @property
-    def var(self):
-        """
-        Returns the complex variable used by all the transfer functions or
-        ``Series``/``Parallel`` objects in a transfer function matrix.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import p, s
-        >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel
-        >>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
-        >>> G2 = TransferFunction(p, 4 - p, p)
-        >>> G3 = TransferFunction(0, p**4 - 1, p)
-        >>> G4 = TransferFunction(s + 1, s**2 + s + 1, s)
-        >>> S1 = Series(G1, G2)
-        >>> S2 = Series(-G3, Parallel(G2, -G1))
-        >>> tfm1 = TransferFunctionMatrix([[G1], [G2], [G3]])
-        >>> tfm1.var
-        p
-        >>> tfm2 = TransferFunctionMatrix([[-S1, -S2], [S1, S2]])
-        >>> tfm2.var
-        p
-        >>> tfm3 = TransferFunctionMatrix([[G4]])
-        >>> tfm3.var
-        s
-
-        """
-        return self.args[0][0][0].var
-
-    @property
-    def num_inputs(self):
-        """
-        Returns the number of inputs of the system.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import s, p
-        >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
-        >>> G1 = TransferFunction(s + 3, s**2 - 3, s)
-        >>> G2 = TransferFunction(4, s**2, s)
-        >>> G3 = TransferFunction(p**2 + s**2, p - 3, s)
-        >>> tfm_1 = TransferFunctionMatrix([[G2, -G1, G3], [-G2, -G1, -G3]])
-        >>> tfm_1.num_inputs
-        3
-
-        See Also
-        ========
-
-        num_outputs
-
-        """
-        return self._expr_mat.shape[1]
-
-    @property
-    def num_outputs(self):
-        """
-        Returns the number of outputs of the system.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import s
-        >>> from sympy.physics.control.lti import TransferFunctionMatrix
-        >>> from sympy import Matrix
-        >>> M_1 = Matrix([[s], [1/s]])
-        >>> TFM = TransferFunctionMatrix.from_Matrix(M_1, s)
-        >>> print(TFM)
-        TransferFunctionMatrix(((TransferFunction(s, 1, s),), (TransferFunction(1, s, s),)))
-        >>> TFM.num_outputs
-        2
-
-        See Also
-        ========
-
-        num_inputs
-
-        """
-        return self._expr_mat.shape[0]
-
-    @property
-    def shape(self):
-        """
-        Returns the shape of the transfer function matrix, that is, ``(# of outputs, # of inputs)``.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import s, p
-        >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
-        >>> tf1 = TransferFunction(p**2 - 1, s**4 + s**3 - p, p)
-        >>> tf2 = TransferFunction(1 - p, p**2 - 3*p + 7, p)
-        >>> tf3 = TransferFunction(3, 4, p)
-        >>> tfm1 = TransferFunctionMatrix([[tf1, -tf2]])
-        >>> tfm1.shape
-        (1, 2)
-        >>> tfm2 = TransferFunctionMatrix([[-tf2, tf3], [tf1, -tf1]])
-        >>> tfm2.shape
-        (2, 2)
-
-        """
-        return self._expr_mat.shape
-
-    def __neg__(self):
-        neg = -self._expr_mat
-        return _to_TFM(neg, self.var)
-
-    def __getitem__(self, key):
-        trunc = self._expr_mat.__getitem__(key)
-        if isinstance(trunc, ImmutableMatrix):
-            return _to_TFM(trunc, self.var)
-        return TransferFunction.from_rational_expression(trunc, self.var)
-
-    def transpose(self):
-        """Returns the transpose of the ``TransferFunctionMatrix`` (switched input and output layers)."""
-        transposed_mat = self._expr_mat.transpose()
-        return _to_TFM(transposed_mat, self.var)
-
-    def elem_poles(self):
-        """
-        Returns the poles of each element of the ``TransferFunctionMatrix``.
-
-        .. note::
-            Actual poles of a MIMO system are NOT the poles of individual elements.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import s
-        >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
-        >>> tf_1 = TransferFunction(3, (s + 1), s)
-        >>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
-        >>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
-        >>> tf_4 = TransferFunction(s + 2, s**2 + 5*s - 10, s)
-        >>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
-        >>> tfm_1
-        TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s + 2, s**2 + 5*s - 10, s))))
-        >>> tfm_1.elem_poles()
-        [[[-1], [-2, -1]], [[-2, -1], [-5/2 + sqrt(65)/2, -sqrt(65)/2 - 5/2]]]
-
-        See Also
-        ========
-
-        elem_zeros
-
-        """
-        return [[element.poles() for element in row] for row in self.doit().args[0]]
-
-    def elem_zeros(self):
-        """
-        Returns the zeros of each element of the ``TransferFunctionMatrix``.
-
-        .. note::
-            Actual zeros of a MIMO system are NOT the zeros of individual elements.
-
-        Examples
-        ========
-
-        >>> from sympy.abc import s
-        >>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
-        >>> tf_1 = TransferFunction(3, (s + 1), s)
-        >>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
-        >>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
-        >>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)
-        >>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
-        >>> tfm_1
-        TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s))))
-        >>> tfm_1.elem_zeros()
-        [[[], [-6]], [[-3], [4, 5]]]
-
-        See Also
-        ========
-
-        elem_poles
-
-        """
-        return [[element.zeros() for element in row] for row in self.doit().args[0]]
-
-    def _flat(self):
-        """Returns flattened list of args in TransferFunctionMatrix"""
-        return [elem for tup in self.args[0] for elem in tup]
diff --git a/sympy/printing/latex.py b/sympy/printing/latex.py
index debc81ca8d..eb663eec7f 100644
--- a/sympy/printing/latex.py
+++ b/sympy/printing/latex.py
@@ -2482,10 +2482,6 @@ def _print_Feedback(self, expr):
         denom = self._print(den)
         return r"\frac{%s}{%s}" % (numer, denom)
 
-    def _print_TransferFunctionMatrix(self, expr):
-        mat = self._print(expr._expr_mat)
-        return r"%s_\tau" % mat
-
     def _print_NamedMorphism(self, morphism):
         pretty_name = self._print(Symbol(morphism.name))
         pretty_morphism = self._print_Morphism(morphism)
diff --git a/sympy/printing/pretty/pretty.py b/sympy/printing/pretty/pretty.py
index 050afbaa14..06bd234787 100644
--- a/sympy/printing/pretty/pretty.py
+++ b/sympy/printing/pretty/pretty.py
@@ -1013,13 +1013,6 @@ def _print_Feedback(self, expr):
 
         return self._print(num)/self._print(den)
 
-    def _print_TransferFunctionMatrix(self, expr):
-        mat = self._print(expr._expr_mat)
-        mat.baseline = mat.height() - 1
-        subscript = greek_unicode['tau'] if self._use_unicode else r'{t}'
-        mat = prettyForm(*mat.right(subscript))
-        return mat
-
     def _print_BasisDependent(self, expr):
         from sympy.vector import Vector
 
diff --git a/sympy/simplify/fu.py b/sympy/simplify/fu.py
index 71ec4418b9..1e3ac74c0d 100644
--- a/sympy/simplify/fu.py
+++ b/sympy/simplify/fu.py
@@ -254,8 +254,8 @@ def TR4(rv):
 
         a=  0   pi/6        pi/4        pi/3        pi/2
     ----------------------------------------------------
-    sin(a)  0   1/2         sqrt(2)/2   sqrt(3)/2   1
-    cos(a)  1   sqrt(3)/2   sqrt(2)/2   1/2         0
+    cos(a)  0   1/2         sqrt(2)/2   sqrt(3)/2   1
+    sin(a)  1   sqrt(3)/2   sqrt(2)/2   1/2         0
     tan(a)  0   sqt(3)/3    1           sqrt(3)     --
 
     Examples


Test patch:
diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py
index fdfa03dd59..8eb52785eb 100644
--- a/sympy/core/tests/test_args.py
+++ b/sympy/core/tests/test_args.py
@@ -4147,13 +4147,6 @@ def test_sympy__physics__control__lti__Feedback():
     assert _test_args(Feedback(tf1, tf2))
 
 
-def test_sympy__physics__control__lti__TransferFunctionMatrix():
-    from sympy.physics.control import TransferFunction, TransferFunctionMatrix
-    tf1 = TransferFunction(x**2 - y**3, y - z, x)
-    tf2 = TransferFunction(y - x, z + y, x)
-    assert _test_args(TransferFunctionMatrix([[tf1, tf2]]))
-
-
 def test_sympy__physics__units__dimensions__Dimension():
     from sympy.physics.units.dimensions import Dimension
     assert _test_args(Dimension("length", "L"))
diff --git a/sympy/physics/control/tests/test_lti.py b/sympy/physics/control/tests/test_lti.py
index 44bd737492..a084f235d5 100644
--- a/sympy/physics/control/tests/test_lti.py
+++ b/sympy/physics/control/tests/test_lti.py
@@ -1,16 +1,9 @@
-from sympy import (symbols, factor, Function, simplify, exp, oo, I,
-    S, Mul, Pow, Add, Rational, sqrt, CRootOf)
-from sympy.core.containers import Tuple
-from sympy.matrices import ImmutableMatrix, Matrix
-from sympy.physics.control import (TransferFunction, Series, Parallel,
-    Feedback, TransferFunctionMatrix)
+from sympy import symbols, Matrix, factor, Function, simplify, exp, oo, I, \
+    Rational, sqrt, CRootOf, S, Mul, Pow, Add
+from sympy.physics.control.lti import TransferFunction, Series, Parallel, Feedback
 from sympy.testing.pytest import raises
 
-a, x, b, s, g, d, p, k, a0, a1, a2, b0, b1, b2, tau, zeta, wn = symbols('a, x, b, s, g, d, p, k,\
-    a0:3, b0:3, tau, zeta, wn')
-TF1 = TransferFunction(1, s**2 + 2*zeta*wn*s + wn**2, s)
-TF2 = TransferFunction(k, 1, s)
-TF3 = TransferFunction(a2*p - s, a2*s + p, s)
+a, x, b, s, g, d, p, k, a0, a1, a2, b0, b1, b2, tau = symbols('a, x, b, s, g, d, p, k, a0:3, b0:3, tau')
 
 
 def test_TransferFunction_construction():
@@ -306,7 +299,7 @@ def test_TransferFunction_functions():
     assert tf8.to_expr() == Mul((a0*s**5 + 5*s**2 + 3), Pow((s**6 - 3), -1, evaluate=False), evaluate=False)
     assert tf9.to_expr() == Mul((s + 5), Pow((5 + s)*(6 + s), -1, evaluate=False), evaluate=False)
     assert tf10.to_expr() == Mul(S(0), Pow(1, -1, evaluate=False), evaluate=False)
-    assert tf11.to_expr() == Pow(1, -1, evaluate=False)
+    assert tf11.to_expr() == Mul(S(1), Pow(1, -1, evaluate=False), evaluate=False)
 
 def test_TransferFunction_addition_and_subtraction():
     tf1 = TransferFunction(s + 6, s - 5, s)
@@ -734,117 +727,3 @@ def test_Feedback_functions():
         (a0 + s)*(s**2 + 2*s*wn*zeta + wn**2))*(s**2 + 2*s*wn*zeta + wn**2), s)
     assert Feedback(TransferFunction(1, 1, p), tf4).rewrite(TransferFunction) == \
         TransferFunction(p, a0*p + p + p**a1 - s, p)
-
-
-def test_TransferFunctionMatrix_construction():
-    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
-    tf4 = TransferFunction(a0*p + p**a1 - s, p, p)
-
-    tfm3_ = TransferFunctionMatrix([[-TF3]])
-    assert tfm3_.shape == (tfm3_.num_outputs, tfm3_.num_inputs) == (1, 1)
-    assert tfm3_.args == Tuple(Tuple(Tuple(-TF3)))
-    assert tfm3_.var == s
-
-    tfm5 = TransferFunctionMatrix([[TF1, -TF2], [TF3, tf5]])
-    assert tfm5.shape == (tfm5.num_outputs, tfm5.num_inputs) == (2, 2)
-    assert tfm5.args == Tuple(Tuple(Tuple(TF1, -TF2), Tuple(TF3, tf5)))
-    assert tfm5.var == s
-
-    tfm7 = TransferFunctionMatrix([[TF1, TF2], [TF3, -tf5], [-tf5, TF2]])
-    assert tfm7.shape == (tfm7.num_outputs, tfm7.num_inputs) == (3, 2)
-    assert tfm7.args == Tuple(Tuple(Tuple(TF1, TF2), Tuple(TF3, -tf5), Tuple(-tf5, TF2)))
-    assert tfm7.var == s
-
-    # all transfer functions will use the same complex variable. tf4 uses 'p'.
-    raises(ValueError, lambda: TransferFunctionMatrix([[TF1], [TF2], [tf4]]))
-    raises(ValueError, lambda: TransferFunctionMatrix([[TF1, tf4], [TF3, tf5]]))
-
-    # length of all the lists in the TFM should be equal.
-    raises(ValueError, lambda: TransferFunctionMatrix([[TF1], [TF3, tf5]]))
-    raises(ValueError, lambda: TransferFunctionMatrix([[TF1, TF3], [tf5]]))
-
-    # lists should only support transfer functions in them.
-    raises(TypeError, lambda: TransferFunctionMatrix([[TF1, TF2], [TF3, Matrix([1, 2])]]))
-    raises(TypeError, lambda: TransferFunctionMatrix([[TF1, Matrix([1, 2])], [TF3, TF2]]))
-
-    # `arg` should strictly be nested list of TransferFunction
-    raises(ValueError, lambda: TransferFunctionMatrix([TF1, TF2, tf5]))
-    raises(ValueError, lambda: TransferFunctionMatrix([TF1]))
-
-def test_TransferFunctionMatrix_functions():
-    tf5 = TransferFunction(a1*s**2 + a2*s - a0, s + a0, s)
-
-    #  Classmethod (from_matrix)
-
-    mat_1 = ImmutableMatrix([
-        [s*(s + 1)*(s - 3)/(s**4 + 1), 2],
-        [p, p*(s + 1)/(s*(s**1 + 1))]
-        ])
-    mat_2 = ImmutableMatrix([[(2*s + 1)/(s**2 - 9)]])
-    mat_3 = ImmutableMatrix([[1, 2], [3, 4]])
-    assert TransferFunctionMatrix.from_Matrix(mat_1, s) == \
-        TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)],
-        [TransferFunction(p, 1, s), TransferFunction(p, s, s)]])
-    assert TransferFunctionMatrix.from_Matrix(mat_2, s) == \
-        TransferFunctionMatrix([[TransferFunction(2*s + 1, s**2 - 9, s)]])
-    assert TransferFunctionMatrix.from_Matrix(mat_3, p) == \
-        TransferFunctionMatrix([[TransferFunction(1, 1, p), TransferFunction(2, 1, p)],
-        [TransferFunction(3, 1, p), TransferFunction(4, 1, p)]])
-
-    #  Negating a TFM
-
-    tfm1 = TransferFunctionMatrix([[TF1], [TF2]])
-    assert -tfm1 == TransferFunctionMatrix([[-TF1], [-TF2]])
-
-    tfm2 = TransferFunctionMatrix([[TF1, TF2, TF3], [tf5, -TF1, -TF3]])
-    assert -tfm2 == TransferFunctionMatrix([[-TF1, -TF2, -TF3], [-tf5, TF1, TF3]])
-
-    # subs()
-
-    H_1 = TransferFunctionMatrix.from_Matrix(mat_1, s)
-    H_2 = TransferFunctionMatrix([[TransferFunction(a*p*s, k*s**2, s), TransferFunction(p*s, k*(s**2 - a), s)]])
-    assert H_1.subs(p, 1) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]])
-    assert H_1.subs({p: 1}) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]])
-    assert H_1.subs({p: 1, s: 1}) == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s)], [TransferFunction(1, 1, s), TransferFunction(1, s, s)]]) # This should ignore `s` as it is `var`
-    assert H_2.subs(p, 2) == TransferFunctionMatrix([[TransferFunction(2*a*s, k*s**2, s), TransferFunction(2*s, k*(-a + s**2), s)]])
-    assert H_2.subs(k, 1) == TransferFunctionMatrix([[TransferFunction(a*p*s, s**2, s), TransferFunction(p*s, -a + s**2, s)]])
-    assert H_2.subs(a, 0) == TransferFunctionMatrix([[TransferFunction(0, k*s**2, s), TransferFunction(p*s, k*s**2, s)]])
-    assert H_2.subs({p: 1, k: 1, a: a0}) == TransferFunctionMatrix([[TransferFunction(a0*s, s**2, s), TransferFunction(s, -a0 + s**2, s)]])
-
-    # transpose()
-
-    assert H_1.transpose() == TransferFunctionMatrix([[TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(p, 1, s)], [TransferFunction(2, 1, s), TransferFunction(p, s, s)]])
-    assert H_2.transpose() == TransferFunctionMatrix([[TransferFunction(a*p*s, k*s**2, s)], [TransferFunction(p*s, k*(-a + s**2), s)]])
-    assert H_1.transpose().transpose() == H_1
-    assert H_2.transpose().transpose() == H_2
-
-    # elem_poles()
-
-    assert H_1.elem_poles() == [[[-sqrt(2)/2 - sqrt(2)*I/2, -sqrt(2)/2 + sqrt(2)*I/2, sqrt(2)/2 - sqrt(2)*I/2, sqrt(2)/2 + sqrt(2)*I/2], []],
-        [[], [0]]]
-    assert H_2.elem_poles() == [[[0, 0], [sqrt(a), -sqrt(a)]]]
-    assert tfm2.elem_poles() == [[[wn*(-zeta + sqrt((zeta - 1)*(zeta + 1))), wn*(-zeta - sqrt((zeta - 1)*(zeta + 1)))], [], [-p/a2]],
-        [[-a0], [wn*(-zeta + sqrt((zeta - 1)*(zeta + 1))), wn*(-zeta - sqrt((zeta - 1)*(zeta + 1)))], [-p/a2]]]
-
-    # elem_zeros()
-
-    assert H_1.elem_zeros() == [[[-1, 0, 3], []], [[], []]]
-    assert H_2.elem_zeros() == [[[0], [0]]]
-    assert tfm2.elem_zeros() == [[[], [], [a2*p]],
-        [[-a2/(2*a1) - sqrt(4*a0*a1 + a2**2)/(2*a1), -a2/(2*a1) + sqrt(4*a0*a1 + a2**2)/(2*a1)], [], [a2*p]]]
-
-    # doit()
-
-    H_3 = TransferFunctionMatrix([[Series(TransferFunction(1, s**3 - 3, s), TransferFunction(s**2 - 2*s + 5, 1, s), TransferFunction(1, s, s))]])
-    H_4 = TransferFunctionMatrix([[Parallel(TransferFunction(s**3 - 3, 4*s**4 - s**2 - 2*s + 5, s), TransferFunction(4 - s**3, 4*s**4 - s**2 - 2*s + 5, s))]])
-
-    assert H_3.doit() == TransferFunctionMatrix([[TransferFunction(s**2 - 2*s + 5, s*(s**3 - 3), s)]])
-    assert H_4.doit() == TransferFunctionMatrix([[TransferFunction((4 - s**3)*(4*s**4 - s**2 - 2*s + 5) + (s**3 - 3)*(4*s**4 - s**2 - 2*s + 5),
-        (4*s**4 - s**2 - 2*s + 5)**2, s)]])
-
-    # _flat()
-
-    assert H_1._flat() == [TransferFunction(s*(s - 3)*(s + 1), s**4 + 1, s), TransferFunction(2, 1, s), TransferFunction(p, 1, s), TransferFunction(p, s, s)]
-    assert H_2._flat() == [TransferFunction(a*p*s, k*s**2, s), TransferFunction(p*s, k*(-a + s**2), s)]
-    assert H_3._flat() == [Series(TransferFunction(1, s**3 - 3, s), TransferFunction(s**2 - 2*s + 5, 1, s), TransferFunction(1, s, s))]
-    assert H_4._flat() == [Parallel(TransferFunction(s**3 - 3, 4*s**4 - s**2 - 2*s + 5, s), TransferFunction(4 - s**3, 4*s**4 - s**2 - 2*s + 5, s))]
diff --git a/sympy/printing/pretty/tests/test_pretty.py b/sympy/printing/pretty/tests/test_pretty.py
index 0afcb045bc..42fae775d3 100644
--- a/sympy/printing/pretty/tests/test_pretty.py
+++ b/sympy/printing/pretty/tests/test_pretty.py
@@ -28,8 +28,7 @@
 from sympy.matrices.expressions import hadamard_power
 
 from sympy.physics import mechanics
-from sympy.physics.control.lti import (TransferFunction, Feedback, TransferFunctionMatrix,
-    Series, Parallel)
+from sympy.physics.control.lti import TransferFunction, Series, Parallel, Feedback
 from sympy.physics.units import joule, degree
 from sympy.printing.pretty import pprint, pretty as xpretty
 from sympy.printing.pretty.pretty_symbology import center_accent, is_combining
@@ -2552,86 +2551,6 @@ def test_pretty_Feedback():
     assert upretty(Feedback(tf5, tf)) == expected8
 
 
-def test_pretty_TransferFunctionMatrix():
-    tf1 = TransferFunction(x + y, x - 2*y, y)
-    tf2 = TransferFunction(x - y, x + y, y)
-    tf3 = TransferFunction(y**2 - 2*y + 1, y + 5, y)
-    tf4 = TransferFunction(y, x**2 + x + 1, y)
-    tf5 = TransferFunction(1 - x, x - y, y)
-    tf6 = TransferFunction(2, 2, y)
-    expected1 = \
-"""\
-⎡ x + y ⎤ \n\
-⎢───────⎥ \n\
-⎢x - 2⋅y⎥ \n\
-⎢       ⎥ \n\
-⎢ x - y ⎥ \n\
-⎢ ───── ⎥ \n\
-⎣ x + y ⎦τ\
-"""
-    expected2 = \
-"""\
-⎡    x + y     ⎤ \n\
-⎢   ───────    ⎥ \n\
-⎢   x - 2⋅y    ⎥ \n\
-⎢              ⎥ \n\
-⎢    x - y     ⎥ \n\
-⎢    ─────     ⎥ \n\
-⎢    x + y     ⎥ \n\
-⎢              ⎥ \n\
-⎢   2          ⎥ \n\
-⎢- y  + 2⋅y - 1⎥ \n\
-⎢──────────────⎥ \n\
-⎣    y + 5     ⎦τ\
-"""
-    expected3 = \
-"""\
-⎡   x + y        x - y   ⎤ \n\
-⎢  ───────       ─────   ⎥ \n\
-⎢  x - 2⋅y       x + y   ⎥ \n\
-⎢                        ⎥ \n\
-⎢ 2                      ⎥ \n\
-⎢y  - 2⋅y + 1      y     ⎥ \n\
-⎢────────────  ──────────⎥ \n\
-⎢   y + 5       2        ⎥ \n\
-⎢              x  + x + 1⎥ \n\
-⎢                        ⎥ \n\
-⎢   1 - x          2     ⎥ \n\
-⎢   ─────          ─     ⎥ \n\
-⎣   x - y          2     ⎦τ\
-"""
-    expected4 = \
-"""\
-⎡    x - y        x + y       y     ⎤ \n\
-⎢    ─────       ───────  ──────────⎥ \n\
-⎢    x + y       x - 2⋅y   2        ⎥ \n\
-⎢                         x  + x + 1⎥ \n\
-⎢                                   ⎥ \n\
-⎢   2                               ⎥ \n\
-⎢- y  + 2⋅y - 1   x - 1      -2     ⎥ \n\
-⎢──────────────   ─────      ───    ⎥ \n\
-⎣    y + 5        x - y       2     ⎦τ\
-"""
-    expected5 = \
-"""\
-⎡ x + y  x - y   x + y       y     ⎤ \n\
-⎢───────⋅─────  ───────  ──────────⎥ \n\
-⎢x - 2⋅y x + y  x - 2⋅y   2        ⎥ \n\
-⎢                        x  + x + 1⎥ \n\
-⎢                                  ⎥ \n\
-⎢  1 - x   2     x + y      -2     ⎥ \n\
-⎢  ───── + ─    ───────     ───    ⎥ \n\
-⎣  x - y   2    x - 2⋅y      2     ⎦τ\
-"""
-
-    assert upretty(TransferFunctionMatrix([[tf1], [tf2]])) == expected1
-    assert upretty(TransferFunctionMatrix([[tf1], [tf2], [-tf3]])) == expected2
-    assert upretty(TransferFunctionMatrix([[tf1, tf2], [tf3, tf4], [tf5, tf6]])) == expected3
-    assert upretty(TransferFunctionMatrix([[tf2, tf1, tf4], [-tf3, -tf5, -tf6]])) == expected4
-    assert upretty(TransferFunctionMatrix([[Series(tf2, tf1), tf1, tf4], [Parallel(tf6, tf5), tf1, -tf6]])) == \
-        expected5
-
-
 def test_pretty_order():
     expr = O(1)
     ascii_str = \
diff --git a/sympy/printing/tests/test_latex.py b/sympy/printing/tests/test_latex.py
index a286dcf8dd..f04d04c404 100644
--- a/sympy/printing/tests/test_latex.py
+++ b/sympy/printing/tests/test_latex.py
@@ -40,8 +40,7 @@
     fibonacci, tribonacci
 from sympy.logic import Implies
 from sympy.logic.boolalg import And, Or, Xor
-from sympy.physics.control.lti import TransferFunction, Series, Parallel, \
-    Feedback, TransferFunctionMatrix
+from sympy.physics.control.lti import TransferFunction, Series, Parallel, Feedback
 from sympy.physics.quantum import Commutator, Operator
 from sympy.physics.units import meter, gibibyte, microgram, second
 from sympy.core.trace import Tr
@@ -2288,16 +2287,6 @@ def test_Parallel_printing():
         r'\left(\frac{- x + y}{x + y}\right) \left(\frac{x y^{2} - z}{- t^{3} + y^{3}}\right)'
 
 
-def test_TransferFunctionMatrix_printing():
-    tf1 = TransferFunction(p, p + x, p)
-    tf2 = TransferFunction(-s + p, p + s, p)
-    tf3 = TransferFunction(p, y**2 + 2*y + 3, p)
-    assert latex(TransferFunctionMatrix([[tf1], [tf2]])) == \
-        r'\left[\begin{matrix}\frac{p}{p + x}\\\frac{p - s}{p + s}\end{matrix}\right]_\tau'
-    assert latex(TransferFunctionMatrix([[tf1, tf2], [tf3, -tf1]])) == \
-        r'\left[\begin{matrix}\frac{p}{p + x} & \frac{p - s}{p + s}\\\frac{p}{y^{2} + 2 y + 3} & \frac{\left(-1\right) p}{p + x}\end{matrix}\right]_\tau'
-
-
 def test_Feedback_printing():
     tf1 = TransferFunction(p, p + x, p)
     tf2 = TransferFunction(-s + p, p + s, p)
diff --git a/sympy/printing/tests/test_str.py b/sympy/printing/tests/test_str.py
index 080f6e5d08..68c7d63769 100644
--- a/sympy/printing/tests/test_str.py
+++ b/sympy/printing/tests/test_str.py
@@ -9,8 +9,7 @@
 from sympy.core import Expr, Mul
 from sympy.core.parameters import _exp_is_pow
 from sympy.external import import_module
-from sympy.physics.control.lti import TransferFunction, Series, Parallel, \
-    Feedback, TransferFunctionMatrix
+from sympy.physics.control.lti import TransferFunction, Series, Parallel, Feedback
 from sympy.physics.units import second, joule
 from sympy.polys import (Poly, rootof, RootSum, groebner, ring, field, ZZ, QQ,
     ZZ_I, QQ_I, lex, grlex)
@@ -703,16 +702,6 @@ def test_Feedback_str():
         "Feedback(TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(1, 1, y))"
 
 
-def test_TransferFunctionMatrix_str():
-    tf1 = TransferFunction(x*y**2 - z, y**3 - t**3, y)
-    tf2 = TransferFunction(x - y, x + y, y)
-    tf3 = TransferFunction(t*x**2 - t**w*x + w, t - y, y)
-    assert str(TransferFunctionMatrix([[tf1], [tf2]])) == \
-        "TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y),), (TransferFunction(x - y, x + y, y),)))"
-    assert str(TransferFunctionMatrix([[tf1, tf2], [tf3, tf2]])) == \
-        "TransferFunctionMatrix(((TransferFunction(x*y**2 - z, -t**3 + y**3, y), TransferFunction(x - y, x + y, y)), (TransferFunction(t*x**2 - t**w*x + w, t - y, y), TransferFunction(x - y, x + y, y))))"
-
-
 def test_Quaternion_str_printer():
     q = Quaternion(x, y, z, t)
     assert str(q) == "x + y*i + z*j + t*k"