DOC: reformat, add to some docstrings / comments

Reformat for 78 character length; one typo.
Add some extra comments.

Author: matthew-brett

nibabel/arraywriters.py

@@ -414,10 +414,10 @@ def _iu2iu(self):
         if self._out_dtype.kind == 'u':
             # We're checking for a sign flip.  This can only work for uint
             # output, because, for int output, the abs min of the type is
-            # greater than the abs max, so the data either fit into the range
-            # (tested for in _do_scaling), or this test can't pass
-            # Need abs that deals with max neg ints. abs problem only arises
-            # when all the data is set to max neg integer value
+            # greater than the abs max, so the data either fits into the range
+            # (tested for in _do_scaling), or this test can't pass. Need abs
+            # that deals with max neg ints. abs problem only arises when all
+            # the data is set to max neg integer value
             imax = np.iinfo(self._out_dtype).max
             if mx <= 0 and int_abs(mn) <= imax: # sign flip enough?
                 # -1.0 * arr will be in scaler_dtype precision
@@ -589,7 +589,8 @@ def _iu2iu(self):
         super(SlopeInterArrayWriter, self)._iu2iu()
 
     def _range_scale(self, in_min, in_max):
-        """ Calculate scaling, intercept based on data range and output type """
+        """ Calculate scaling, intercept based on data range and output type
+        """
         if in_max == in_min: # Only one number in array
             self.slope = 1.
             self.inter = in_min
@@ -604,10 +605,10 @@ def _range_scale(self, in_min, in_max):
             in_min, in_max = np.array([in_min, in_max], dtype=big_float)
             in_range = np.diff([in_min, in_max])
         else: # max possible (u)int range is 2**64-1 (int64, uint64)
-            # int_to_float covers this range.  On windows longdouble is the same
-            # as double so in_range will be 2**64 - thus overestimating slope
-            # slightly.  Casting to int needed to allow in_max-in_min to be larger than
-            # the largest (u)int value
+            # int_to_float covers this range.  On windows longdouble is the
+            # same as double so in_range will be 2**64 - thus overestimating
+            # slope slightly.  Casting to int needed to allow in_max-in_min to
+            # be larger than the largest (u)int value
             in_min, in_max = as_int(in_min), as_int(in_max)
             in_range = int_to_float(in_max - in_min, big_float)
             # Cast to float for later processing.
@@ -624,13 +625,13 @@ def _range_scale(self, in_min, in_max):
             # raise an error when writing
             out_min, out_max = shared_range(working_dtype, out_dtype)
             out_min, out_max = np.array((out_min, out_max), dtype = big_float)
-        # We want maximum precision for the calculations. Casting will
-        # not lose precision because min/max are of fp type.
+        # We want maximum precision for the calculations. Casting will not lose
+        # precision because min/max are of fp type.
         assert [v.dtype.kind for v in (out_min, out_max)] == ['f', 'f']
         out_range = out_max - out_min
         """
-        Think of the input values as a line starting (left) at in_min and ending
-        (right) at in_max.
+        Think of the input values as a line starting (left) at in_min and
+        ending (right) at in_max.
 
         The output values will be a line starting at out_min and ending at
         out_max.
@@ -666,20 +667,20 @@ def _range_scale(self, in_min, in_max):
         We can't change the range of the saved data (the whole range of the
         integer type) or the range of the output data (the values we input). We
         can change the intermediate values ``saved_data * slope`` by choosing
-        the sign of the slope to match the in_min or in_max to the left or right
-        end of the saved data range.
+        the sign of the slope to match the in_min or in_max to the left or
+        right end of the saved data range.
 
-        If the out_dtype is signed int, then abs(out_min) = abs(out_max) + 1 and
-        the absolute value and therefore precision for values at the left and
-        right of the saved data range are very similar (e.g. -128 * slope, 127 *
-        slope respectively).
+        If the out_dtype is signed int, then abs(out_min) = abs(out_max) + 1
+        and the absolute value and therefore precision for values at the left
+        and right of the saved data range are very similar (e.g. -128 * slope,
+        127 * slope respectively).
 
-        If the out_dtype is unsigned int, then the absolute value at the left is
-        0 and the precision is much higher than for the right end of the range
-        (e.g. 0 * slope, 255 * slope).
+        If the out_dtype is unsigned int, then the absolute value at the left
+        is 0 and the precision is much higher than for the right end of the
+        range (e.g. 0 * slope, 255 * slope).
 
-        If the out_dtype is unsigned int then we choose the sign of the slope to
-        match the smaller of the in_min, in_max to the zero end of the saved
+        If the out_dtype is unsigned int then we choose the sign of the slope
+        to match the smaller of the in_min, in_max to the zero end of the saved
         range.
         """
         if out_min == 0 and np.abs(in_max) < np.abs(in_min):

nibabel/casting.py

@@ -107,8 +107,8 @@ def shared_range(flt_type, int_type):
     """ Min and max in float type that are >=min, <=max in integer type
 
     This is not as easy as it sounds, because the float type may not be able to
-    exactly represent the max or min integer values, so we have to find the next
-    exactly representable floating point value to do the thresholding.
+    exactly represent the max or min integer values, so we have to find the
+    next exactly representable floating point value to do the thresholding.
 
     Parameters
     ----------

nibabel/tests/test_spm99analyze.py

@@ -81,7 +81,8 @@ def test_data_scaling(self):
         assert_true(np.all(data == data_back))
 
 
-class TestSpm99AnalyzeHeader(test_analyze.TestAnalyzeHeader, HeaderScalingMixin):
+class TestSpm99AnalyzeHeader(test_analyze.TestAnalyzeHeader,
+                             HeaderScalingMixin):
     header_class = Spm99AnalyzeHeader
 
     def test_empty(self):
@@ -210,9 +211,10 @@ def test_header_scaling(self):
         # For images that implement scaling, test effect of scaling
         #
         # This tests the affect of creating an image with a header containing
-        # the scaling, then writing the image and reading again.  So the scaling
-        # can be affected by the processing of the header when creating the
-        # image, or by interpretation of the scaling when creating the array.
+        # the scaling, then writing the image and reading again.  So the
+        # scaling can be affected by the processing of the header when creating
+        # the image, or by interpretation of the scaling when creating the
+        # array.
         #
         # Analyze does not implement any scaling, but this test class is the
         # base class for all Analyze-derived classes, such as NIfTI
@@ -227,9 +229,12 @@ def test_header_scaling(self):
         if not hdr_class.has_data_intercept:
             return
         invalid_inters = (np.nan, np.inf, -np.inf)
-        invalid_pairs = tuple(itertools.product(invalid_slopes, invalid_inters))
-        bad_slopes_good_inter = tuple(itertools.product(invalid_slopes, (0, 1)))
-        good_slope_bad_inters = tuple(itertools.product((1, 2), invalid_inters))
+        invalid_pairs = tuple(
+            itertools.product(invalid_slopes, invalid_inters))
+        bad_slopes_good_inter = tuple(
+            itertools.product(invalid_slopes, (0, 1)))
+        good_slope_bad_inters = tuple(
+            itertools.product((1, 2), invalid_inters))
         for slope, inter in (invalid_pairs + bad_slopes_good_inter +
                              good_slope_bad_inters):
             self.assert_null_scaling(arr, slope, inter)
@@ -240,8 +245,8 @@ def _check_write_scaling(self,
                              effective_slope,
                              effective_inter):
         # Test that explicit set of slope / inter forces write of data using
-        # this slope, inter
-        # We use this helper function for children of the Analyze header
+        # this slope, inter.  We use this helper function for children of the
+        # Analyze header
         img_class = self.image_class
         arr = np.arange(24, dtype=np.float32).reshape((2, 3, 4))
         # We're going to test rounding later
@@ -316,11 +321,12 @@ def test_int_int_scaling(self):
 
     @scipy_skip
     def test_no_scaling(self):
-        # Test writing image converting types when no scaling
+        # Test writing image converting types when not calculating scaling
         img_class = self.image_class
         hdr_class = img_class.header_class
         hdr = hdr_class()
         supported_types = supported_np_types(hdr)
+        # Any old non-default slope and intercept
         slope = 2
         inter = 10 if hdr.has_data_intercept else 0
         for in_dtype, out_dtype in itertools.product(
@@ -331,6 +337,7 @@ def test_no_scaling(self):
             arr = np.array([mn_in, -1, 0, 1, 10, mx_in], dtype=in_dtype)
             img = img_class(arr, np.eye(4), hdr)
             img.set_data_dtype(out_dtype)
+            # Setting the scaling means we don't calculate it later
             img.header.set_slope_inter(slope, inter)
             with np.errstate(invalid='ignore'):
                 rt_img = bytesio_round_trip(img)
@@ -437,16 +444,17 @@ def test_mat_read(self):
         to_111 = np.eye(4)
         to_111[:3,3] = 1
         assert_array_equal(mats['mat'], np.dot(aff, from_111))
-        # The M matrix does not include flips, so if we only
-        # have the M matrix in the mat file, and we have default flipping, the
-        # mat resulting should have a flip.  The 'mat' matrix does include flips
-        # and so should be unaffected by the flipping.  If both are present we
-        # prefer the the 'mat' matrix.
+        # The M matrix does not include flips, so if we only have the M matrix
+        # in the mat file, and we have default flipping, the mat resulting
+        # should have a flip.  The 'mat' matrix does include flips and so
+        # should be unaffected by the flipping.  If both are present we prefer
+        # the the 'mat' matrix.
         assert_true(img.header.default_x_flip) # check the default
         flipper = np.diag([-1,1,1,1])
         assert_array_equal(mats['M'], np.dot(aff, np.dot(flipper, from_111)))
         mat_fileobj.seek(0)
-        savemat(mat_fileobj, dict(M=np.diag([3,4,5,1]), mat=np.diag([6,7,8,1])))
+        savemat(mat_fileobj,
+                dict(M=np.diag([3,4,5,1]), mat=np.diag([6,7,8,1])))
         # Check we are preferring the 'mat' matrix
         r_img = img_klass.from_file_map(fm)
         assert_array_equal(r_img.get_data(), arr)