Add missing hermitian option to MatrixPinv

aesara/tensor/nlinalg.py

@@ -18,26 +18,10 @@ logger = logging.getLogger(__name__)
 
 
 class MatrixPinv(Op):
-    """Computes the pseudo-inverse of a matrix :math:`A`.
-
-    The pseudo-inverse of a matrix :math:`A`, denoted :math:`A^+`, is
-    defined as: "the matrix that 'solves' [the least-squares problem]
-    :math:`Ax = b`," i.e., if :math:`\\bar{x}` is said solution, then
-    :math:`A^+` is that matrix such that :math:`\\bar{x} = A^+b`.
-
-    Note that :math:`Ax=AA^+b`, so :math:`AA^+` is close to the identity matrix.
-    This method is not faster than `matrix_inverse`. Its strength comes from
-    that it works for non-square matrices.
-    If you have a square matrix though, `matrix_inverse` can be both more
-    exact and faster to compute. Also this op does not get optimized into a
-    solve op.
+    __props__ = ("hermitian",)
 
-    """
-
-    __props__ = ()
-
-    def __init__(self):
-        pass
+    def __init__(self, hermitian):
+        self.hermitian = hermitian
 
     def make_node(self, x):
         x = as_tensor_variable(x)
@@ -47,7 +31,7 @@ class MatrixPinv(Op):
     def perform(self, node, inputs, outputs):
         (x,) = inputs
         (z,) = outputs
-        z[0] = np.linalg.pinv(x).astype(x.dtype)
+        z[0] = np.linalg.pinv(x, hermitian=self.hermitian).astype(x.dtype)
 
     def L_op(self, inputs, outputs, g_outputs):
         r"""The gradient function should return
@@ -75,8 +59,46 @@ class MatrixPinv(Op):
         ).T
         return [grad]
 
+    def infer_shape(self, fgraph, node, shapes):
+        return [list(reversed(shapes[0]))]
+
+
+def pinv(x, hermitian=False):
+    """Computes the pseudo-inverse of a matrix :math:`A`.
+
+    The pseudo-inverse of a matrix :math:`A`, denoted :math:`A^+`, is
+    defined as: "the matrix that 'solves' [the least-squares problem]
+    :math:`Ax = b`," i.e., if :math:`\\bar{x}` is said solution, then
+    :math:`A^+` is that matrix such that :math:`\\bar{x} = A^+b`.
+
+    Note that :math:`Ax=AA^+b`, so :math:`AA^+` is close to the identity matrix.
+    This method is not faster than `matrix_inverse`. Its strength comes from
+    that it works for non-square matrices.
+    If you have a square matrix though, `matrix_inverse` can be both more
+    exact and faster to compute. Also this op does not get optimized into a
+    solve op.
+
+    """
+    return MatrixPinv(hermitian=hermitian)(x)
+
+
+class Inv(Op):
+    """Computes the inverse of one or more matrices."""
+
+    def make_node(self, x):
+        x = as_tensor_variable(x)
+        return Apply(self, [x], [x.type()])
+
+    def perform(self, node, inputs, outputs):
+        (x,) = inputs
+        (z,) = outputs
+        z[0] = np.linalg.inv(x).astype(x.dtype)
+
+    def infer_shape(self, fgraph, node, shapes):
+        return shapes
+
 
-pinv = MatrixPinv()
+inv = Inv()
 
 
 class MatrixInverse(Op):