DOC: various docstring reformats

matthew-brett · matthew-brett · commit 3af6877da43b · 2018-01-15T09:37:28.000Z
Rewrapping, some small numpy docstring fixes.
diff --git a/nipy/core/reference/__init__.py b/nipy/core/reference/__init__.py
@@ -5,12 +5,14 @@
 
 Mathematical model
 ==================
-The idea of a chart :lm:`\\phi` : I{U} S{sub} I{M} S{->} B{R}^k
-on a "manifold" I{M}.  For a chart both input (I{M}) and output coordinates
-(B{R}^k) must be defined and a map relating the two coordinate systems.
+
+The idea is of a chart $\phi : I{U} S{sub} I{M} S{->} B{R}^k$ on a "manifold"
+$I{M}$.  For a chart, both input ($I{M}$) and output coordinates ($B{R}^k$)
+must be defined and there must be a map relating the two coordinate systems.
 
 Description
 ===========
+
 The modules in this package contains classes which define the space in which an
 image exists and also functions for manipulating and traversing this space.
 
@@ -19,22 +21,23 @@
 output CoordinateSystem, and a mapping which converts points in the
 input space to points in the output space.
 
-A `CoordinateSystem` consists of a set of ordered `Coordinate` objects. Each
+A ``CoordinateSystem`` consists of a set of ordered ``Coordinate`` objects. Each
 Coordinate has a name and a builtin dtype.
 
-The typical use of a `CoordinateMap` is to define how voxels in an `Image`
-(core.image.__init__.py) object's raw data map into real space. 
+The typical use of a ``CoordinateMap`` is to define how voxels in an ``Image``
+(``core.image.__init__.py``) object's raw data map into real space. 
 
-`Image` traversal is general done in terms of the underlying coordinate_map, and a number of
-iterators are provided to traverse points in the coordinate_map (iterators.py). Access to
-available iterators is done through the CoordinateMap interface, rather than 
-accessing the iterator classes directly. 
-
-The other common image access method is to take slices through the coordinate_map. In 
-slices.py functions are presented which will return a `CoordinateMap` representing
-a single slice through a larger coordinate_map.
+``Image`` traversal is in general done in terms of the underlying
+coordinate_map, and a number of iterators are provided to traverse points in
+the coordinate_map (iterators.py). Access to available iterators is done
+through the CoordinateMap interface, rather than accessing the iterator classes
+directly.
 
+The other common image access method is to take slices through the
+coordinate_map. In slices.py functions are presented which will return a
+``CoordinateMap`` representing a single slice through a larger coordinate_map.
 """
+
 from __future__ import absolute_import
 __docformat__ = 'restructuredtext'
 
diff --git a/nipy/core/reference/coordinate_map.py b/nipy/core/reference/coordinate_map.py
@@ -4,15 +4,13 @@
 This module describes two types of *mappings*:
 
 * CoordinateMap: a general function from a domain to a range, with a possible
-     inverse function.
-
+  inverse function;
 * AffineTransform: an affine function from a domain to a range, not
-     necessarily of the same dimension, hence not always invertible.
+  necessarily of the same dimension, hence not always invertible.
 
-Each of these objects is meant to encapsulate a tuple of
-(domain, range, function).
-Each of the mapping objects contain all the details about their domain
-CoordinateSystem, their range CoordinateSystem and the mapping between
+Each of these objects is meant to encapsulate a tuple of (domain, range,
+function).  Each of the mapping objects contain all the details about their
+domain CoordinateSystem, their range CoordinateSystem and the mapping between
 them.
 
 Common API
@@ -21,13 +19,16 @@
 They are separate classes, neither one inheriting from the other.
 They do, however, share some parts of an API, each having methods:
 
-* renamed_domain : rename on the coordinates of the domain (returns a new mapping)
+* renamed_domain : rename on the coordinates of the domain (returns a new
+  mapping)
 
 * renamed_range : rename the coordinates of the range (returns a new mapping)
 
-* reordered_domain : reorder the coordinates of the domain (returns a new mapping)
+* reordered_domain : reorder the coordinates of the domain (returns a new
+  mapping)
 
-* reordered_range : reorder the coordinates of the range (returns a new mapping)
+* reordered_range : reorder the coordinates of the range (returns a new
+  mapping)
 
 * inverse : when appropriate, return the inverse *mapping*
 
@@ -45,20 +46,19 @@
 -----------------------------------------------
 
 * compose : Take a sequence of mappings (either CoordinateMaps or
-   AffineTransforms) and return their composition. If they are all
-   AffineTransforms, an AffineTransform is returned. This checks to
-   ensure that domains and ranges of the various mappings agree.
+  AffineTransforms) and return their composition. If they are all
+  AffineTransforms, an AffineTransform is returned. This checks to ensure that
+  domains and ranges of the various mappings agree.
 * product : Take a sequence of mappings (either CoordinateMaps or
-   AffineTransforms) and return a new mapping that has domain and range
-   given by the concatenation of their domains and ranges, and the
-   mapping simply concatenates the output of each of the individual
-   mappings. If they are all AffineTransforms, an AffineTransform is
-   returned. If they are all AffineTransforms that are in fact linear
-   (i.e. origin=0) then can is represented as a block matrix with the
-   size of the blocks determined by
+  AffineTransforms) and return a new mapping that has domain and range given by
+  the concatenation of their domains and ranges, and the mapping simply
+  concatenates the output of each of the individual mappings. If they are all
+  AffineTransforms, an AffineTransform is returned. If they are all
+  AffineTransforms that are in fact linear (i.e. origin=0) then can is
+  represented as a block matrix with the size of the blocks determined by
 * concat : Take a mapping and prepend a coordinate to its domain and
-   range.  For mapping `m`, this is the same as
-   product(AffineTransform.identity('concat'), `m`)
+  range.  For mapping ``m``, this is the same as
+  ``product(AffineTransform.identity('concat'), m)``
 """
 from __future__ import absolute_import
 
