Patch refactor (#16)

Author: mmuckley

README.md

@@ -30,11 +30,11 @@ interpolation, sparse matrix-based NUFFT interpolation, and forward/backward
 operators with Toeplitz-embedded FFTs [[3](#references)]. Roughly, computation
 speed follows:
 
-| Type          | Speed                                |
-| ------------- | ------------------------------------ |
-| Toeplitz      | Fastest                              |
-| Table         | Medium                               |
-| Sparse Matrix | Slow (Faster for many-coil problems) |
+| Type          | Speed                  |
+| ------------- | ---------------------- |
+| Toeplitz      | Fastest                |
+| Table         | Medium                 |
+| Sparse Matrix | Slow (not recommended) |
 
 It is generally best to start with Table interpolation and then experiment with
 the other modes for your problem.

docs/source/index.rst

@@ -15,8 +15,8 @@ About
 [`1 <https://doi.org/10.1109/TSP.2002.807005>`_,
 `2 <https://doi.org/10.1109/TMI.2005.848376>`_] with
 Kaiser-Bessel gridding in PyTorch. The implementation is completely in Python,
-facilitating flexible deployment in human-readable code with no compilation.
-NUFFT functions are each wrapped as a :py:class:`torch.autograd.Function`, allowing
+facilitating flexible deployment in readable code with no compilation. NUFFT
+functions are each wrapped as a :py:class:`torch.autograd.Function`, allowing
 backpropagation through NUFFT operators for training neural networks.
 
 This package was inspired in large part by the NUFFT implementation in the
@@ -41,11 +41,11 @@ Operation Modes and Stages
 The package has three major classes of NUFFT operation mode: table-based NUFFT
 interpolation, sparse matrix-based NUFFT interpolation, and forward/backward
 operators with Toeplitz-embedded FFTs
-[`3 <https://doi.org/10.1007/s002110050101>`_]. The Toeplitz method is always the
-fastest for forward/backward NUFFTs. Depending on the problem, either the table
-or sparse matrix NUFFTs can be faster in other cases. It is generally best to
-start with Table interpolation and then experiment with the other modes for
-your problem.
+[`3 <https://doi.org/10.1007/s002110050101>`_]. Table interpolation is the
+standard operation mode, whereas the Toeplitz method is always the
+fastest for forward/backward NUFFTs. For some problems, sparse matrices may be
+fast. It is generally best to start with Table interpolation and then experiment
+with the other modes for your problem.
 
 Sensitivity maps can be incorporated by passing them into a
 :py:class:`~torchkbnufft.KbNufft` or :py:class:`~torchkbnufft.KbNufftAdjoint`

notebooks/Basic Example.ipynb

@@ -21,7 +21,7 @@ def calc_density_compensation_function(
     """Numerical density compensation estimation.
 
     This function has optional parameters for initializing a NUFFT object. See
-    :py:meth:`~torchkbnufft.KbInterp` for details.
+    :py:class:`~torchkbnufft.KbInterp` for details.
 
     * :attr:`ktraj` should be of size ``(len(im_size), klength)``,
       where ``klength`` is the length of the k-space trajectory.

notebooks/SENSE Example.ipynb

@@ -24,7 +24,7 @@ def calc_tensor_spmatrix(
     table interpolation.
 
     This function has optional parameters for initializing a NUFFT object. See
-    :py:meth:`~torchkbnufft.KbNufft` for details.
+    :py:class:`~torchkbnufft.KbNufft` for details.
 
     * :attr:`omega` should be of size ``(len(im_size), klength)``,
       where ``klength`` is the length of the k-space trajectory.

notebooks/Sparse Matrix Example.ipynb

@@ -34,7 +34,12 @@ def calc_toeplitz_kernel(
     <https://link.springer.com/article/10.1007/s002110050101>`_.
 
     This function has optional parameters for initializing a NUFFT object. See
-    :py:meth:`~torchkbnufft.KbNufftAdjoint` for details.
+    :py:class:`~torchkbnufft.KbNufftAdjoint` for details.
+
+    Note:
+
+        This function is intended to be used in conjunction with
+        :py:class:`~torchkbnufft.ToepNufft` for forward operations.
 
     * :attr:`omega` should be of size ``(len(im_size), klength)``,
       where ``klength`` is the length of the k-space trajectory.

notebooks/Toeplitz Example.ipynb

@@ -108,10 +108,11 @@ def forward(
     ) -> Tensor:
         """Interpolate from gridded data to scattered data.
 
-        Input tensors should be of shape ``(N, C) + im_size``, where ``N`` is
+        Input tensors should be of shape ``(N, C) + grid_size``, where ``N`` is
         the batch size and ``C`` is the number of sensitivity coils. ``omega``,
-        the k-space trajectory, should be of size ``(len(im_size), klength)``,
-        where ``klength`` is the length of the k-space trajectory.
+        the k-space trajectory, should be of size
+        ``(len(grid_size), klength)``, where ``klength`` is the length of the
+        k-space trajectory.
 
         If your tensors are real-valued, ensure that 2 is the size of the last
         dimension.
@@ -256,7 +257,7 @@ def forward(
                 interpolation).
 
         Returns:
-            ``data`` transformed to the image domain.
+            ``data`` interpolated to the grid.
         """
         is_complex = True
         if not data.is_complex():