Only doc user function, not the class.

doc/library/sparse/index.txt

@@ -119,16 +119,18 @@ List of Implemented Operations
 ==============================
 
 - Moving from and to sparse
-    - :class:`DenseFromSparse <theano.sparse.basic.DenseFromSparse>` and ``dense_from_sparse``.
+    - :func:`dense_from_sparse <theano.sparse.basic.dense_from_sparse>`.
       Both grads are implemented. Structured by default.
-    - :class:`SparseFromDense <theano.sparse.basic.SparseFromDense>` and ``csr_from_dense``, ``csc_from_dense``.
+    - :func:`csr_from_dense <theano.sparse.basic.csr_from_dense>`,
+      :func:`csc_from_dense <theano.sparse.basic.csc_from_dense>`.
       The grad implemented is structured.
-    - Theano SparseVariable object have a method ``toarray()`` that is the same as ``dense_from_sparse``.
+    - Theano SparseVariable object have a method ``toarray()`` that is the same as
+      :func:`dense_from_sparse <theano.sparse.basic.dense_from_sparse>`.
 
 - Construction of Sparses and their Properties
     - :class:`CSM <theano.sparse.basic.CSM>` and ``CSC``, ``CSR`` to construct a matrix.
       The grad implemented is regular.
-    - :class:`CSMProperties <theano.sparse.basic.CSMProperties>` and ``csm_properties(x)``
+    - :func:`csm_properties <theano.sparse.basic.csm_properties>`.
       to get the properties of a sparse matrix.
       The grad implemented is regular.
     - csm_indices(x), csm_indptr(x), csm_data(x) and csm_shape(x) or x.shape.
@@ -136,22 +138,22 @@ List of Implemented Operations
       The grad implemented is regular.
     - :func:`sp_zeros_like <theano.sparse.basic.sp_zeros_like>`.
       The grad implemented is regular.
-    - :class:`SquareDiagonal <theano.sparse.basic.SquareDiagonal>` and ``square_diagonal``.
+    - :func:`square_diagonal <theano.sparse.basic.square_diagonal>`.
       The grad implemented is regular.
-    - :class:`ConstructSparseFromList <theano.sparse.basic.ConstructSparseFromList>` and ``construct_sparse_from_list``.
+    - :func:`construct_sparse_from_list <theano.sparse.basic.construct_sparse_from_list>`.
       The grad implemented is regular.
 
 - Cast
-    - :class:`Cast <theano.sparse.basic.Cast>` with ``bcast``, ``wcast``, ``icast``, ``lcast``,
+    - :func:`cast <theano.sparse.basic.cast>` with ``bcast``, ``wcast``, ``icast``, ``lcast``,
       ``fcast``, ``dcast``, ``ccast``, and ``zcast``.
       The grad implemented is regular.
 
 - Transpose
-    - :class:`Transpose <theano.sparse.basic.Transpose>` and ``transpose``.
+    - :func:`Transpose <theano.sparse.basic.transpose>`.
       The grad implemented is regular.
 
 - Basic Arithmetic
-    - :class:`Neg <theano.sparse.basic.Neg>`.
+    - :func:`neg <theano.sparse.basic.neg>`.
       The grad implemented is regular.
     - :func:`eq <theano.sparse.basic.eq>`.
     - :func:`neq <theano.sparse.basic.neq>`.
@@ -201,15 +203,13 @@ List of Implemented Operations
     - ``sqrt``
 
 - Dot Product
-    - :class:`Dot <theano.sparse.basic.Dot>` and
-      :func:`dot <theano.sparse.basic.dot>`.
+    - :func:`dot <theano.sparse.basic.dot>`.
 
         - One of the inputs must be sparse, the other sparse or dense.
         - The grad implemented is regular.
         - No C code for perform and no C code for grad.
         - Returns a dense for perform and a dense for grad.
-    - :class:`StructuredDot <theano.sparse.basic.StructuredDot>`
-      and :func:`structured_dot <theano.sparse.basic.structured_dot>`.
+    - :func:`structured_dot <theano.sparse.basic.structured_dot>`.
 
         - The first input is sparse, the second can be sparse or dense.
         - The grad implemented is structured.
@@ -218,8 +218,7 @@ List of Implemented Operations
           dense one if one of the inputs is dense.
         - Returns a sparse grad for sparse inputs and dense grad for
           dense inputs.
-    - :class:`TrueDot <theano.sparse.basic.TrueDot>` and
-      :func:`true_dot <theano.sparse.basic.true_dot>`.
+    - :func:`true_dot <theano.sparse.basic.true_dot>`.
 
         - The first input is sparse, the second can be sparse or dense.
         - The grad implemented is regular.
@@ -229,19 +228,18 @@ List of Implemented Operations
           default a dense for dense inputs. The parameter
           ``grad_preserves_dense`` can be set to False to return a
           sparse grad for dense inputs.
-    - :class:`SamplingDot <theano.sparse.basic.SamplingDot>` and
-      ``sampling_dot``.
+    - :func:`sampling_dot <theano.sparse.basic.sampling_dot>`.
 
         - Both inputs must be dense.
         - The grad implemented is structured for `p`.
         - Sample of the dot and sample of the gradient.
         - C code for perform but not for grad.
         - Returns sparse for perform and grad.
-    - :class:`Usmm <theano.sparse.basic.Usmm>` and ``usmm``.
+    - :func:`usmm <theano.sparse.basic.usmm>`.
 
         - You *shouldn't* insert this op yourself!
            - There is an optimization that transform a
-             :class:`Dot <theano.sparse.basic.Dot>` to ``Usmm`` when possible.
+             :func:`dot <theano.sparse.basic.dot>` to ``Usmm`` when possible.
 
         - This op is the equivalent of gemm for sparse dot.
         - There is no grad implemented for this op.
@@ -256,13 +254,13 @@ List of Implemented Operations
     - Sparse variables don't support [M, N:O] and [M:N, O] as we don't
       support sparse vectors and returning a sparse matrix would break
       the numpy interface.  Use [M:M+1, N:O] and [M:N, O:O+1] instead.
-    - :class:`Diag <theano.sparse.basic.Diag>` and ``diag``.
+    - :func:`diag <theano.sparse.basic.diag>`.
       The grad implemented is regular.
 
 - Concatenation
-    - :class:`HStack <theano.sparse.basic.HStack>` and ``hstack``.
+    - :func:`hstack <theano.sparse.basic.hstack>`.
       The grad implemented is regular.
-    - :class:`VStack <theano.sparse.basic.VStack>` and ``vstack``.
+    - :func:`vstack <theano.sparse.basic.vstack>`.
       The grad implemented is regular.
 
 - Probability
@@ -276,8 +274,8 @@ List of Implemented Operations
 - Internal Representation
     `They all have a regular grad implemented.`
 
-    - :class:`EnsureSortedIndices <theano.sparse.basic.EnsureSortedIndices>` and ``ensure_sorted_indices``
-    - :class:`Remove0 <theano.sparse.basic.Remove0>` and ``remove0``
+    - :func:`ensure_sorted_indices <theano.sparse.basic.ensure_sorted_indices>`.
+    - :func:`remove0 <theano.sparse.basic.remove0>`.
     - :func:`clean <theano.sparse.basic.clean>` to resort indices and remove zeros
 
 - To help testing

theano/sparse/basic.py

@@ -3730,19 +3730,7 @@ def dot(x, y):
 
 
 class Usmm(gof.op.Op):
-    """Performs the expression is `alpha` * `x` `y` + `z`.
-
-    :param x: Matrix variable.
-    :param y: Matrix variable.
-    :param z: Dense matrix.
-    :param alpha: A tensor scalar.
-
-    :return: The dense matrix resulting from `alpha` * `x` `y` + `z`.
-
-    :note: The grad is not implemented for this op.
-    :note: At least one of `x` or `y` must be a sparse matrix.
-    """
-
+    # See doc in instance of this Op or function after this class definition.
     # We don't implement the infer_shape as it is
     # inserted by optimization only.
 
@@ -3802,13 +3790,22 @@ class Usmm(gof.op.Op):
 
         out[0] = rval
 usmm = Usmm()
+"""Performs the expression is `alpha` * `x` `y` + `z`.
 
+:param x: Matrix variable.
+:param y: Matrix variable.
+:param z: Dense matrix.
+:param alpha: A tensor scalar.
 
-class ConstructSparseFromList(gof.Op):
-    """Constructs a sparse matrix out of a list of 2-D matrix rows
+:return: The dense matrix resulting from `alpha` * `x` `y` + `z`.
 
-    :note: The grad implemented is regular, i.e. not structured.
-    """
+:note: The grad is not implemented for this op.
+:note: At least one of `x` or `y` must be a sparse matrix.
+"""
+
+
+class ConstructSparseFromList(gof.Op):
+    # See doc in instance of this Op or function after this class definition.
     def __hash__(self):
         return hash((type(self)))
 
@@ -3898,3 +3895,7 @@ class ConstructSparseFromList(gof.Op):
         return [gx, gy] + [DisconnectedType()()] * len(idx_list)
 
 construct_sparse_from_list = ConstructSparseFromList()
+"""Constructs a sparse matrix out of a list of 2-D matrix rows
+
+:note: The grad implemented is regular, i.e. not structured.
+"""