Merge pull request #6046 from charris/pep8-and-pyflakes-cleanups

PEP8 and pyflakes fixups for numpy/ma/*.py and numpy/ma/tests/*.py

Merge cleanups prior to 1.10 release.

15 files changed, 1438 insertions, 1250 deletions

diff --git a/numpy/lib/tests/test_io.py b/numpy/lib/tests/test_io.py
index 8a939f85e..fbeb7fb0a 100644
--- a/numpy/lib/tests/test_io.py
+++ b/numpy/lib/tests/test_io.py
@@ -13,15 +13,17 @@ from datetime import datetime
 
 import numpy as np
 import numpy.ma as ma
-from numpy.lib._iotools import (ConverterError, ConverterLockError,
-                                ConversionWarning)
+from numpy.lib._iotools import (
+    ConverterError, ConverterLockError, ConversionWarning
+    )
 from numpy.compat import asbytes, bytes, unicode
 from nose import SkipTest
-from numpy.ma.testutils import (
-    TestCase, assert_equal, assert_array_equal, assert_allclose,
-    assert_raises, assert_raises_regex, run_module_suite
-)
-from numpy.testing import assert_warns, assert_, build_err_msg
+from numpy.ma.testutils import assert_equal, assert_almost_equal
+from numpy.testing import (
+    TestCase, run_module_suite, assert_warns, assert_, build_err_msg,
+    assert_raises_regex, assert_raises, assert_allclose,
+    assert_array_equal,
+    )
 from numpy.testing.utils import tempdir
 
 
diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py
index 13e75cbd0..09cc29dc1 100644
--- a/numpy/lib/tests/test_recfunctions.py
+++ b/numpy/lib/tests/test_recfunctions.py
@@ -3,9 +3,8 @@ from __future__ import division, absolute_import, print_function
 import numpy as np
 import numpy.ma as ma
 from numpy.ma.mrecords import MaskedRecords
-from numpy.ma.testutils import (
-    run_module_suite, TestCase, assert_, assert_equal
-    )
+from numpy.ma.testutils import assert_equal
+from numpy.testing import TestCase, run_module_suite, assert_
 from numpy.lib.recfunctions import (
     drop_fields, rename_fields, get_fieldstructure, recursive_fill_fields,
     find_duplicates, merge_arrays, append_fields, stack_arrays, join_by
diff --git a/numpy/ma/__init__.py b/numpy/ma/__init__.py
index 0cb92f667..05b641dff 100644
--- a/numpy/ma/__init__.py
+++ b/numpy/ma/__init__.py
@@ -35,14 +35,12 @@ may now proceed to calculate the mean of the other values:
 .. [1] Not-a-Number, a floating point value that is the result of an
        invalid operation.
 
+.. moduleauthor:: Pierre Gerard-Marchant
+.. moduleauthor:: Jarrod Millman
+
 """
 from __future__ import division, absolute_import, print_function
 
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
 from . import core
 from .core import *
 
diff --git a/numpy/ma/bench.py b/numpy/ma/bench.py
index 75e6d90c8..b86197018 100644
--- a/numpy/ma/bench.py
+++ b/numpy/ma/bench.py
@@ -1,22 +1,16 @@
-#! python
-# encoding: utf-8
-from __future__ import division, absolute_import, print_function
+#! /usr/bin/env python
+from __future__ import division, print_function
 
 import timeit
-#import IPython.ipapi
-#ip = IPython.ipapi.get()
-#from IPython import ipmagic
 import numpy
-#from numpy import ma
-#from numpy.ma import filled
-#from numpy.ma.testutils import assert_equal
 
 
-#####---------------------------------------------------------------------------
-#---- --- Global variables ---
-#####---------------------------------------------------------------------------
+###############################################################################
+#                               Global variables                              #
+###############################################################################
+
 
-# Small arrays ..................................
+# Small arrays
 xs = numpy.random.uniform(-1, 1, 6).reshape(2, 3)
 ys = numpy.random.uniform(-1, 1, 6).reshape(2, 3)
 zs = xs + 1j * ys
@@ -25,7 +19,8 @@ m2 = [[True, False, True], [False, False, True]]
 nmxs = numpy.ma.array(xs, mask=m1)
 nmys = numpy.ma.array(ys, mask=m2)
 nmzs = numpy.ma.array(zs, mask=m1)
-# Big arrays ....................................
+
+# Big arrays
 xl = numpy.random.uniform(-1, 1, 100*100).reshape(100, 100)
 yl = numpy.random.uniform(-1, 1, 100*100).reshape(100, 100)
 zl = xl + 1j * yl
@@ -35,9 +30,11 @@ nmxl = numpy.ma.array(xl, mask=maskx)
 nmyl = numpy.ma.array(yl, mask=masky)
 nmzl = numpy.ma.array(zl, mask=maskx)
 
-#####---------------------------------------------------------------------------
-#---- --- Functions ---
-#####---------------------------------------------------------------------------
+
+###############################################################################
+#                                 Functions                                   #
+###############################################################################
+
 
 def timer(s, v='', nloop=500, nrep=3):
     units = ["s", "ms", "µs", "ns"]
@@ -55,8 +52,6 @@ def timer(s, v='', nloop=500, nrep=3):
                                                       3,
                                                       best * scaling[order],
                                                       units[order]))
-#    ip.magic('timeit -n%i %s' % (nloop,s))
-
 
 
 def compare_functions_1v(func, nloop=500,
@@ -66,7 +61,7 @@ def compare_functions_1v(func, nloop=500,
     print("%s on small arrays" % funcname)
     module, data = "numpy.ma", "nmxs"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
-    #
+
     print("%s on large arrays" % funcname)
     module, data = "numpy.ma", "nmxl"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
@@ -78,7 +73,7 @@ def compare_methods(methodname, args, vars='x', nloop=500, test=True,
     print("%s on small arrays" % methodname)
     data, ver = "nm%ss" % vars, 'numpy.ma'
     timer("%(data)s.%(methodname)s(%(args)s)" % locals(), v=ver, nloop=nloop)
-    #
+
     print("%s on large arrays" % methodname)
     data, ver = "nm%sl" % vars, 'numpy.ma'
     timer("%(data)s.%(methodname)s(%(args)s)" % locals(), v=ver, nloop=nloop)
@@ -94,51 +89,22 @@ def compare_functions_2v(func, nloop=500, test=True,
     print("%s on small arrays" % funcname)
     module, data = "numpy.ma", "nmxs,nmys"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
-    #
+
     print("%s on large arrays" % funcname)
     module, data = "numpy.ma", "nmxl,nmyl"
     timer("%(module)s.%(funcname)s(%(data)s)" % locals(), v="%11s" % module, nloop=nloop)
     return
 
 
-###############################################################################
-
-
-################################################################################
 if __name__ == '__main__':
-#    # Small arrays ..................................
-#    xs = numpy.random.uniform(-1,1,6).reshape(2,3)
-#    ys = numpy.random.uniform(-1,1,6).reshape(2,3)
-#    zs = xs + 1j * ys
-#    m1 = [[True, False, False], [False, False, True]]
-#    m2 = [[True, False, True], [False, False, True]]
-#    nmxs = numpy.ma.array(xs, mask=m1)
-#    nmys = numpy.ma.array(ys, mask=m2)
-#    nmzs = numpy.ma.array(zs, mask=m1)
-#    mmxs = maskedarray.array(xs, mask=m1)
-#    mmys = maskedarray.array(ys, mask=m2)
-#    mmzs = maskedarray.array(zs, mask=m1)
-#    # Big arrays ....................................
-#    xl = numpy.random.uniform(-1,1,100*100).reshape(100,100)
-#    yl = numpy.random.uniform(-1,1,100*100).reshape(100,100)
-#    zl = xl + 1j * yl
-#    maskx = xl > 0.8
-#    masky = yl < -0.8
-#    nmxl = numpy.ma.array(xl, mask=maskx)
-#    nmyl = numpy.ma.array(yl, mask=masky)
-#    nmzl = numpy.ma.array(zl, mask=maskx)
-#    mmxl = maskedarray.array(xl, mask=maskx, shrink=True)
-#    mmyl = maskedarray.array(yl, mask=masky, shrink=True)
-#    mmzl = maskedarray.array(zl, mask=maskx, shrink=True)
-#
     compare_functions_1v(numpy.sin)
     compare_functions_1v(numpy.log)
     compare_functions_1v(numpy.sqrt)
-    #....................................................................
+
     compare_functions_2v(numpy.multiply)
     compare_functions_2v(numpy.divide)
     compare_functions_2v(numpy.power)
-    #....................................................................
+
     compare_methods('ravel', '', nloop=1000)
     compare_methods('conjugate', '', 'z', nloop=1000)
     compare_methods('transpose', '', nloop=1000)
@@ -148,7 +114,7 @@ if __name__ == '__main__':
     compare_methods('__getitem__', '[0,-1]', nloop=1000)
     compare_methods('__setitem__', '0, 17', nloop=1000, test=False)
     compare_methods('__setitem__', '(0,0), 17', nloop=1000, test=False)
-    #....................................................................
+
     print("-"*50)
     print("__setitem__ on small arrays")
     timer('nmxs.__setitem__((-1,0),numpy.ma.masked)', 'numpy.ma   ', nloop=10000)
@@ -157,7 +123,6 @@ if __name__ == '__main__':
     print("__setitem__ on large arrays")
     timer('nmxl.__setitem__((-1,0),numpy.ma.masked)', 'numpy.ma   ', nloop=10000)
 
-    #....................................................................
     print("-"*50)
     print("where on small arrays")
     timer('numpy.ma.where(nmxs>2,nmxs,nmys)', 'numpy.ma   ', nloop=1000)
diff --git a/numpy/ma/core.py b/numpy/ma/core.py
index c47bcc073..d4771fb31 100644
--- a/numpy/ma/core.py
+++ b/numpy/ma/core.py
@@ -40,58 +40,50 @@ if sys.version_info[0] >= 3:
 else:
     import cPickle as pickle
 
-__author__ = "Pierre GF Gerard-Marchant"
-__docformat__ = "restructuredtext en"
-
-__all__ = ['MAError', 'MaskError', 'MaskType', 'MaskedArray',
-           'bool_',
-           'abs', 'absolute', 'add', 'all', 'allclose', 'allequal', 'alltrue',
-           'amax', 'amin', 'angle', 'anom', 'anomalies', 'any', 'append', 'arange',
-           'arccos', 'arccosh', 'arcsin', 'arcsinh', 'arctan', 'arctan2',
-           'arctanh', 'argmax', 'argmin', 'argsort', 'around',
-           'array', 'asarray', 'asanyarray',
-           'bitwise_and', 'bitwise_or', 'bitwise_xor',
-           'ceil', 'choose', 'clip', 'common_fill_value', 'compress',
-           'compressed', 'concatenate', 'conjugate', 'copy', 'cos', 'cosh',
-           'count', 'cumprod', 'cumsum',
-           'default_fill_value', 'diag', 'diagonal', 'diff', 'divide', 'dump',
-           'dumps',
-           'empty', 'empty_like', 'equal', 'exp', 'expand_dims',
-           'fabs', 'flatten_mask', 'fmod', 'filled', 'floor', 'floor_divide',
-           'fix_invalid', 'flatten_structured_array', 'frombuffer', 'fromflex',
-           'fromfunction',
-           'getdata', 'getmask', 'getmaskarray', 'greater', 'greater_equal',
-           'harden_mask', 'hypot',
-           'identity', 'ids', 'indices', 'inner', 'innerproduct',
-           'isMA', 'isMaskedArray', 'is_mask', 'is_masked', 'isarray',
-           'left_shift', 'less', 'less_equal', 'load', 'loads', 'log', 'log2',
-           'log10', 'logical_and', 'logical_not', 'logical_or', 'logical_xor',
-           'make_mask', 'make_mask_descr', 'make_mask_none', 'mask_or',
-           'masked', 'masked_array', 'masked_equal', 'masked_greater',
-           'masked_greater_equal', 'masked_inside', 'masked_invalid',
-           'masked_less', 'masked_less_equal', 'masked_not_equal',
-           'masked_object', 'masked_outside', 'masked_print_option',
-           'masked_singleton', 'masked_values', 'masked_where', 'max', 'maximum',
-           'maximum_fill_value', 'mean', 'min', 'minimum', 'minimum_fill_value',
-           'mod', 'multiply', 'mvoid',
-           'negative', 'nomask', 'nonzero', 'not_equal',
-           'ones', 'outer', 'outerproduct',
-           'power', 'prod', 'product', 'ptp', 'put', 'putmask',
-           'rank', 'ravel', 'remainder', 'repeat', 'reshape', 'resize',
-           'right_shift', 'round_', 'round',
-           'set_fill_value', 'shape', 'sin', 'sinh', 'size', 'sometrue',
-           'sort', 'soften_mask', 'sqrt', 'squeeze', 'std', 'subtract', 'sum',
-           'swapaxes',
-           'take', 'tan', 'tanh', 'trace', 'transpose', 'true_divide',
-           'var', 'where',
-           'zeros']
+__all__ = [
+    'MAError', 'MaskError', 'MaskType', 'MaskedArray', 'abs', 'absolute',
+    'add', 'all', 'allclose', 'allequal', 'alltrue', 'amax', 'amin',
+    'angle', 'anom', 'anomalies', 'any', 'append', 'arange', 'arccos',
+    'arccosh', 'arcsin', 'arcsinh', 'arctan', 'arctan2', 'arctanh',
+    'argmax', 'argmin', 'argsort', 'around', 'array', 'asanyarray',
+    'asarray', 'bitwise_and', 'bitwise_or', 'bitwise_xor', 'bool_', 'ceil',
+    'choose', 'clip', 'common_fill_value', 'compress', 'compressed',
+    'concatenate', 'conjugate', 'copy', 'cos', 'cosh', 'count', 'cumprod',
+    'cumsum', 'default_fill_value', 'diag', 'diagonal', 'diff', 'divide',
+    'dump', 'dumps', 'empty', 'empty_like', 'equal', 'exp', 'expand_dims',
+    'fabs', 'filled', 'fix_invalid', 'flatten_mask',
+    'flatten_structured_array', 'floor', 'floor_divide', 'fmod',
+    'frombuffer', 'fromflex', 'fromfunction', 'getdata', 'getmask',
+    'getmaskarray', 'greater', 'greater_equal', 'harden_mask', 'hypot',
+    'identity', 'ids', 'indices', 'inner', 'innerproduct', 'isMA',
+    'isMaskedArray', 'is_mask', 'is_masked', 'isarray', 'left_shift',
+    'less', 'less_equal', 'load', 'loads', 'log', 'log10', 'log2',
+    'logical_and', 'logical_not', 'logical_or', 'logical_xor', 'make_mask',
+    'make_mask_descr', 'make_mask_none', 'mask_or', 'masked',
+    'masked_array', 'masked_equal', 'masked_greater',
+    'masked_greater_equal', 'masked_inside', 'masked_invalid',
+    'masked_less', 'masked_less_equal', 'masked_not_equal',
+    'masked_object', 'masked_outside', 'masked_print_option',
+    'masked_singleton', 'masked_values', 'masked_where', 'max', 'maximum',
+    'maximum_fill_value', 'mean', 'min', 'minimum', 'minimum_fill_value',
+    'mod', 'multiply', 'mvoid', 'ndim', 'negative', 'nomask', 'nonzero',
+    'not_equal', 'ones', 'outer', 'outerproduct', 'power', 'prod',
+    'product', 'ptp', 'put', 'putmask', 'rank', 'ravel', 'remainder',
+    'repeat', 'reshape', 'resize', 'right_shift', 'round', 'round_',
+    'set_fill_value', 'shape', 'sin', 'sinh', 'size', 'soften_mask',
+    'sometrue', 'sort', 'sqrt', 'squeeze', 'std', 'subtract', 'sum',
+    'swapaxes', 'take', 'tan', 'tanh', 'trace', 'transpose', 'true_divide',
+    'var', 'where', 'zeros',
+    ]
 
 MaskType = np.bool_
 nomask = MaskType(0)
 
+
 def doc_note(initialdoc, note):
     """
     Adds a Notes section to an existing docstring.
+
     """
     if initialdoc is None:
         return
@@ -106,46 +98,55 @@ def doc_note(initialdoc, note):
     """
     return newdoc % (initialdoc, note)
 
+
 def get_object_signature(obj):
     """
     Get the signature from obj
+
     """
     try:
         sig = formatargspec(*getargspec(obj))
-    except TypeError as errmsg:
+    except TypeError:
         sig = ''
-#        msg = "Unable to retrieve the signature of %s '%s'\n"\
-#              "(Initial error message: %s)"
-#        warnings.warn(msg % (type(obj),
-#                             getattr(obj, '__name__', '???'),
-#                             errmsg))
     return sig
 
 
-#####--------------------------------------------------------------------------
-#---- --- Exceptions ---
-#####--------------------------------------------------------------------------
+###############################################################################
+#                              Exceptions                                     #
+###############################################################################
+
+
 class MAError(Exception):
-    """Class for masked array related errors."""
+    """
+    Class for masked array related errors.
+
+    """
     pass
+
+
 class MaskError(MAError):
-    "Class for mask related errors."
+    """
+    Class for mask related errors.
+
+    """
     pass
 
 
-#####--------------------------------------------------------------------------
-#---- --- Filling options ---
-#####--------------------------------------------------------------------------
+###############################################################################
+#                           Filling options                                   #
+###############################################################################
+
+
 # b: boolean - c: complex - f: floats - i: integer - O: object - S: string
 default_filler = {'b': True,
-                  'c' : 1.e20 + 0.0j,
-                  'f' : 1.e20,
-                  'i' : 999999,
-                  'O' : '?',
-                  'S' : 'N/A',
-                  'u' : 999999,
-                  'V' : '???',
-                  'U' : 'N/A'
+                  'c': 1.e20 + 0.0j,
+                  'f': 1.e20,
+                  'i': 999999,
+                  'O': '?',
+                  'S': 'N/A',
+                  'u': 999999,
+                  'V': '???',
+                  'U': 'N/A'
                   }
 
 # Add datetime64 and timedelta64 types
@@ -369,11 +370,13 @@ def _recursive_set_default_fill_value(dtypedescr):
     for currentdescr in dtypedescr:
         currenttype = currentdescr[1]
         if isinstance(currenttype, list):
-            deflist.append(tuple(_recursive_set_default_fill_value(currenttype)))
+            deflist.append(
+                tuple(_recursive_set_default_fill_value(currenttype)))
         else:
             deflist.append(default_fill_value(np.dtype(currenttype)))
     return tuple(deflist)
 
+
 def _recursive_set_fill_value(fillvalue, dtypedescr):
     fillvalue = np.resize(fillvalue, len(dtypedescr))
     output_value = []
@@ -425,7 +428,7 @@ def _check_fill_value(fill_value, ndtype):
             err_msg = "Cannot set fill value of string with array of dtype %s"
             raise TypeError(err_msg % ndtype)
         else:
-            # In case we want to convert 1e20 to int...
+            # In case we want to convert 1e20 to int.
             try:
                 fill_value = np.array(fill_value, copy=False, dtype=ndtype)
             except OverflowError:
@@ -501,6 +504,7 @@ def set_fill_value(a, fill_value):
         a.set_fill_value(fill_value)
     return
 
+
 def get_fill_value(a):
     """
     Return the filling value of a, if any.  Otherwise, returns the
@@ -513,6 +517,7 @@ def get_fill_value(a):
         result = default_fill_value(a)
     return result
 
+
 def common_fill_value(a, b):
     """
     Return the common filling value of two masked arrays, if any.
@@ -545,7 +550,6 @@ def common_fill_value(a, b):
     return None
 
 
-#####--------------------------------------------------------------------------
 def filled(a, fill_value=None):
     """
     Return input as an array with masked data replaced by a fill value.
@@ -591,10 +595,11 @@ def filled(a, fill_value=None):
     else:
         return np.array(a)
 
-#####--------------------------------------------------------------------------
+
 def get_masked_subclass(*arrays):
     """
     Return the youngest subclass of MaskedArray from a list of (masked) arrays.
+
     In case of siblings, the first listed takes over.
 
     """
@@ -617,7 +622,7 @@ def get_masked_subclass(*arrays):
         return MaskedArray
     return rcls
 
-#####--------------------------------------------------------------------------
+
 def getdata(a, subok=True):
     """
     Return the data of a masked array as an ndarray.
@@ -668,6 +673,8 @@ def getdata(a, subok=True):
     if not subok:
         return data.view(ndarray)
     return data
+
+
 get_data = getdata
 
 
@@ -721,7 +728,6 @@ def fix_invalid(a, mask=nomask, copy=True, fill_value=None):
 
     """
     a = masked_array(a, copy=copy, mask=mask, subok=True)
-    #invalid = (numpy.isnan(a._data) | numpy.isinf(a._data))
     invalid = np.logical_not(np.isfinite(a._data))
     if not invalid.any():
         return a
@@ -732,13 +738,15 @@ def fix_invalid(a, mask=nomask, copy=True, fill_value=None):
     return a
 
 
+###############################################################################
+#                                  Ufuncs                                     #
+###############################################################################
+
 
-#####--------------------------------------------------------------------------
-#---- --- Ufuncs ---
-#####--------------------------------------------------------------------------
 ufunc_domain = {}
 ufunc_fills = {}
 
+
 class _DomainCheckInterval:
     """
     Define a valid interval, so that :
@@ -747,6 +755,7 @@ class _DomainCheckInterval:
     ``x < a`` or ``x > b``.
 
     """
+
     def __init__(self, a, b):
         "domain_check_interval(a,b)(x) = true where x < a or y > b"
         if (a > b):
@@ -754,35 +763,39 @@ class _DomainCheckInterval:
         self.a = a
         self.b = b
 
-    def __call__ (self, x):
+    def __call__(self, x):
         "Execute the call behavior."
-        return umath.logical_or(umath.greater (x, self.b),
+        return umath.logical_or(umath.greater(x, self.b),
                                 umath.less(x, self.a))
 
 
-
 class _DomainTan:
-    """Define a valid interval for the `tan` function, so that:
+    """
+    Define a valid interval for the `tan` function, so that:
 
     ``domain_tan(eps) = True`` where ``abs(cos(x)) < eps``
 
     """
+
     def __init__(self, eps):
         "domain_tan(eps) = true where abs(cos(x)) < eps)"
         self.eps = eps
 
-    def __call__ (self, x):
+    def __call__(self, x):
         "Executes the call behavior."
         return umath.less(umath.absolute(umath.cos(x)), self.eps)
 
 
-
 class _DomainSafeDivide:
-    """Define a domain for safe division."""
-    def __init__ (self, tolerance=None):
+    """
+    Define a domain for safe division.
+
+    """
+
+    def __init__(self, tolerance=None):
         self.tolerance = tolerance
 
-    def __call__ (self, a, b):
+    def __call__(self, a, b):
         # Delay the selection of the tolerance to here in order to reduce numpy
         # import times. The calculation of these parameters is a substantial
         # component of numpy's import time.
@@ -793,30 +806,36 @@ class _DomainSafeDivide:
         return umath.absolute(a) * self.tolerance >= umath.absolute(b)
 
 
-
 class _DomainGreater:
-    """DomainGreater(v)(x) is True where x <= v."""
+    """
+    DomainGreater(v)(x) is True where x <= v.
+
+    """
+
     def __init__(self, critical_value):
         "DomainGreater(v)(x) = true where x <= v"
         self.critical_value = critical_value
 
-    def __call__ (self, x):
+    def __call__(self, x):
         "Executes the call behavior."
         return umath.less_equal(x, self.critical_value)
 
 
-
 class _DomainGreaterEqual:
-    """DomainGreaterEqual(v)(x) is True where x < v."""
+    """
+    DomainGreaterEqual(v)(x) is True where x < v.
+
+    """
+
     def __init__(self, critical_value):
         "DomainGreaterEqual(v)(x) = true where x < v"
         self.critical_value = critical_value
 
-    def __call__ (self, x):
+    def __call__(self, x):
         "Executes the call behavior."
         return umath.less(x, self.critical_value)
 
-#..............................................................................
+
 class _MaskedUnaryOperation:
     """
     Defines masked version of unary operations, where invalid values are
@@ -834,12 +853,8 @@ class _MaskedUnaryOperation:
         classes. Default is None.
 
     """
-    def __init__ (self, mufunc, fill=0, domain=None):
-        """ _MaskedUnaryOperation(aufunc, fill=0, domain=None)
-            aufunc(fill) must be defined
-            self(x) returns aufunc(x)
-            with masked values where domain(x) is true or getmask(x) is true.
-        """
+
+    def __init__(self, mufunc, fill=0, domain=None):
         self.f = mufunc
         self.fill = fill
         self.domain = domain
@@ -847,34 +862,42 @@ class _MaskedUnaryOperation:
         self.__name__ = getattr(mufunc, "__name__", str(mufunc))
         ufunc_domain[mufunc] = domain
         ufunc_fills[mufunc] = fill
-    #
-    def __call__ (self, a, *args, **kwargs):
-        "Execute the call behavior."
+
+    def __call__(self, a, *args, **kwargs):
+        """
+        Execute the call behavior.
+
+        """
         d = getdata(a)
-        # Case 1.1. : Domained function
+        # Deal with domain
         if self.domain is not None:
+            # Case 1.1. : Domained function
             with np.errstate(divide='ignore', invalid='ignore'):
                 result = self.f(d, *args, **kwargs)
             # Make a mask
             m = ~umath.isfinite(result)
             m |= self.domain(d)
             m |= getmask(a)
-        # Case 1.2. : Function without a domain
         else:
+            # Case 1.2. : Function without a domain
             # Get the result and the mask
             result = self.f(d, *args, **kwargs)
             m = getmask(a)
-        # Case 2.1. : The result is scalarscalar
+
         if not result.ndim:
+            # Case 2.1. : The result is scalarscalar
             if m:
                 return masked
             return result
-        # Case 2.2. The result is an array
-        # We need to fill the invalid data back w/ the input
-        # Now, that's plain silly: in C, we would just skip the element and keep
-        # the original, but we do have to do it that way in Python
+
         if m is not nomask:
-            # In case result has a lower dtype than the inputs (as in equal)
+            # Case 2.2. The result is an array
+            # We need to fill the invalid data back w/ the input Now,
+            # that's plain silly: in C, we would just skip the element and
+            # keep the original, but we do have to do it that way in Python
+
+            # In case result has a lower dtype than the inputs (as in
+            # equal)
             try:
                 np.copyto(result, d, where=m)
             except TypeError:
@@ -884,10 +907,9 @@ class _MaskedUnaryOperation:
         masked_result._mask = m
         masked_result._update_from(result)
         return masked_result
-    #
-    def __str__ (self):
-        return "Masked version of %s. [Invalid values are masked]" % str(self.f)
 
+    def __str__(self):
+        return "Masked version of %s. [Invalid values are masked]" % str(self.f)
 
 
 class _MaskedBinaryOperation:
@@ -909,9 +931,13 @@ class _MaskedBinaryOperation:
         Filling value for the second argument, default is 0.
 
     """
-    def __init__ (self, mbfunc, fillx=0, filly=0):
-        """abfunc(fillx, filly) must be defined.
-           abfunc(x, filly) = x for all x to enable reduce.
+
+    def __init__(self, mbfunc, fillx=0, filly=0):
+        """
+        abfunc(fillx, filly) must be defined.
+
+        abfunc(x, filly) = x for all x to enable reduce.
+
         """
         self.f = mbfunc
         self.fillx = fillx
@@ -921,8 +947,11 @@ class _MaskedBinaryOperation:
         ufunc_domain[mbfunc] = None
         ufunc_fills[mbfunc] = (fillx, filly)
 
-    def __call__ (self, a, b, *args, **kwargs):
-        "Execute the call behavior."
+    def __call__(self, a, b, *args, **kwargs):
+        """
+        Execute the call behavior.
+
+        """
         # Get the data, as ndarray
         (da, db) = (getdata(a), getdata(b))
         # Get the result
@@ -940,11 +969,13 @@ class _MaskedBinaryOperation:
             m = umath.logical_or(ma, getmaskarray(b))
         else:
             m = umath.logical_or(ma, mb)
+
         # Case 1. : scalar
         if not result.ndim:
             if m:
                 return masked
             return result
+
         # Case 2. : array
         # Revert result to da where masked
         if m is not nomask and m.any():
@@ -958,6 +989,7 @@ class _MaskedBinaryOperation:
                     result += masked_da
             except:
                 pass
+
         # Transforms to a (subclass of) MaskedArray
         masked_result = result.view(get_masked_subclass(a, b))
         masked_result._mask = m
@@ -965,7 +997,10 @@ class _MaskedBinaryOperation:
         return masked_result
 
     def reduce(self, target, axis=0, dtype=None):
-        """Reduce `target` along the given `axis`."""
+        """
+        Reduce `target` along the given `axis`.
+
+        """
         tclass = get_masked_subclass(target)
         m = getmask(target)
         t = filled(target, self.filly)
@@ -993,7 +1028,8 @@ class _MaskedBinaryOperation:
         return masked_tr
 
     def outer(self, a, b):
-        """Return the function applied to the outer product of a and b.
+        """
+        Return the function applied to the outer product of a and b.
 
         """
         (da, db) = (getdata(a), getdata(b))
@@ -1033,7 +1069,6 @@ class _MaskedBinaryOperation:
         return "Masked version of " + str(self.f)
 
 
-
 class _DomainedBinaryOperation:
     """
     Define binary operations that have a domain, like divide.
@@ -1054,7 +1089,8 @@ class _DomainedBinaryOperation:
         Filling value for the second argument, default is 0.
 
     """
-    def __init__ (self, dbfunc, domain, fillx=0, filly=0):
+
+    def __init__(self, dbfunc, domain, fillx=0, filly=0):
         """abfunc(fillx, filly) must be defined.
            abfunc(x, filly) = x for all x to enable reduce.
         """
@@ -1106,10 +1142,10 @@ class _DomainedBinaryOperation:
         masked_result._update_from(result)
         return masked_result
 
-    def __str__ (self):
+    def __str__(self):
         return "Masked version of " + str(self.f)
 
-#..............................................................................
+
 # Unary ufuncs
 exp = _MaskedUnaryOperation(umath.exp)
 conjugate = _MaskedUnaryOperation(umath.conjugate)
@@ -1122,20 +1158,21 @@ sinh = _MaskedUnaryOperation(umath.sinh)
 cosh = _MaskedUnaryOperation(umath.cosh)
 tanh = _MaskedUnaryOperation(umath.tanh)
 abs = absolute = _MaskedUnaryOperation(umath.absolute)
-angle = _MaskedUnaryOperation(angle) # from numpy.lib.function_base
+angle = _MaskedUnaryOperation(angle)  # from numpy.lib.function_base
 fabs = _MaskedUnaryOperation(umath.fabs)
 negative = _MaskedUnaryOperation(umath.negative)
 floor = _MaskedUnaryOperation(umath.floor)
 ceil = _MaskedUnaryOperation(umath.ceil)
 around = _MaskedUnaryOperation(np.round_)
 logical_not = _MaskedUnaryOperation(umath.logical_not)
-# Domained unary ufuncs .......................................................
+
+# Domained unary ufuncs
 sqrt = _MaskedUnaryOperation(umath.sqrt, 0.0,
                              _DomainGreaterEqual(0.0))
 log = _MaskedUnaryOperation(umath.log, 1.0,
                             _DomainGreater(0.0))
 log2 = _MaskedUnaryOperation(umath.log2, 1.0,
-                            _DomainGreater(0.0))
+                             _DomainGreater(0.0))
 log10 = _MaskedUnaryOperation(umath.log10, 1.0,
                               _DomainGreater(0.0))
 tan = _MaskedUnaryOperation(umath.tan, 0.0,
@@ -1148,7 +1185,8 @@ arccosh = _MaskedUnaryOperation(umath.arccosh, 1.0,
                                 _DomainGreaterEqual(1.0))
 arctanh = _MaskedUnaryOperation(umath.arctanh, 0.0,
                                 _DomainCheckInterval(-1.0 + 1e-15, 1.0 - 1e-15))
-# Binary ufuncs ...............................................................
+
+# Binary ufuncs
 add = _MaskedBinaryOperation(umath.add)
 subtract = _MaskedBinaryOperation(umath.subtract)
 multiply = _MaskedBinaryOperation(umath.multiply, 1, 1)
@@ -1174,21 +1212,23 @@ bitwise_and = _MaskedBinaryOperation(umath.bitwise_and)
 bitwise_or = _MaskedBinaryOperation(umath.bitwise_or)
 bitwise_xor = _MaskedBinaryOperation(umath.bitwise_xor)
 hypot = _MaskedBinaryOperation(umath.hypot)
-# Domained binary ufuncs ......................................................
+
+# Domained binary ufuncs
 divide = _DomainedBinaryOperation(umath.divide, _DomainSafeDivide(), 0, 1)
 true_divide = _DomainedBinaryOperation(umath.true_divide,
-                                        _DomainSafeDivide(), 0, 1)
+                                       _DomainSafeDivide(), 0, 1)
 floor_divide = _DomainedBinaryOperation(umath.floor_divide,
-                                         _DomainSafeDivide(), 0, 1)
+                                        _DomainSafeDivide(), 0, 1)
 remainder = _DomainedBinaryOperation(umath.remainder,
-                                      _DomainSafeDivide(), 0, 1)
+                                     _DomainSafeDivide(), 0, 1)
 fmod = _DomainedBinaryOperation(umath.fmod, _DomainSafeDivide(), 0, 1)
 mod = _DomainedBinaryOperation(umath.mod, _DomainSafeDivide(), 0, 1)
 
 
-#####--------------------------------------------------------------------------
-#---- --- Mask creation functions ---
-#####--------------------------------------------------------------------------
+###############################################################################
+#                        Mask creation functions                              #
+###############################################################################
+
 
 def _recursive_make_descr(datatype, newtype=bool_):
     "Private function allowing recursion in make_descr."
@@ -1210,6 +1250,7 @@ def _recursive_make_descr(datatype, newtype=bool_):
     else:
         return newtype
 
+
 def make_mask_descr(ndtype):
     """
     Construct a dtype description list from a given dtype.
@@ -1245,6 +1286,7 @@ def make_mask_descr(ndtype):
         ndtype = np.dtype(ndtype)
     return np.dtype(_recursive_make_descr(ndtype, np.bool))
 
+
 def getmask(a):
     """
     Return the mask of a masked array, or nomask.
@@ -1304,8 +1346,11 @@ def getmask(a):
 
     """
     return getattr(a, '_mask', nomask)
+
+
 get_mask = getmask
 
+
 def getmaskarray(arr):
     """
     Return the mask of a masked array, or full boolean array of False.
@@ -1360,6 +1405,7 @@ def getmaskarray(arr):
         mask = make_mask_none(np.shape(arr), getattr(arr, 'dtype', None))
     return mask
 
+
 def is_mask(m):
     """
     Return True if m is a valid, standard mask.
@@ -1427,6 +1473,7 @@ def is_mask(m):
     except AttributeError:
         return False
 
+
 def make_mask(m, copy=False, shrink=True, dtype=MaskType):
     """
     Create a boolean mask from an array.
@@ -1570,7 +1617,8 @@ def make_mask_none(newshape, dtype=None):
         result = np.zeros(newshape, dtype=make_mask_descr(dtype))
     return result
 
-def mask_or (m1, m2, copy=False, shrink=True):
+
+def mask_or(m1, m2, copy=False, shrink=True):
     """
     Combine two masks with the ``logical_or`` operator.
 
@@ -1606,6 +1654,7 @@ def mask_or (m1, m2, copy=False, shrink=True):
     array([ True,  True,  True, False], dtype=bool)
 
     """
+
     def _recursive_mask_or(m1, m2, newmask):
         names = m1.dtype.names
         for name in names:
@@ -1615,7 +1664,7 @@ def mask_or (m1, m2, copy=False, shrink=True):
             else:
                 umath.logical_or(current1, m2[name], newmask[name])
         return
-    #
+
     if (m1 is nomask) or (m1 is False):
         dtype = getattr(m2, 'dtype', MaskType)
         return make_mask(m2, copy=copy, shrink=shrink, dtype=dtype)
@@ -1665,7 +1714,7 @@ def flatten_mask(mask):
     array([False, False, False, False, False,  True], dtype=bool)
 
     """
-    #
+
     def _flatmask(mask):
         "Flatten the mask and returns a (maybe nested) sequence of booleans."
         mnames = mask.dtype.names
@@ -1673,7 +1722,7 @@ def flatten_mask(mask):
             return [flatten_mask(mask[name]) for name in mnames]
         else:
             return mask
-    #
+
     def _flatsequence(sequence):
         "Generates a flattened version of the sequence."
         try:
@@ -1685,7 +1734,7 @@ def flatten_mask(mask):
                     yield element
         except TypeError:
             yield sequence
-    #
+
     mask = np.asarray(mask)
     flattened = _flatsequence(_flatmask(mask))
     return np.array([_ for _ in flattened], dtype=bool)
@@ -1698,9 +1747,9 @@ def _check_mask_axis(mask, axis):
     return nomask
 
 
-#####--------------------------------------------------------------------------
-#--- --- Masking functions ---
-#####--------------------------------------------------------------------------
+###############################################################################
+#                             Masking functions                               #
+###############################################################################
 
 def masked_where(condition, a, copy=True):
     """
@@ -1974,11 +2023,6 @@ def masked_equal(x, value, copy=True):
           fill_value=999999)
 
     """
-    # An alternative implementation relies on filling first: probably not needed.
-    # d = filled(x, 0)
-    # c = umath.equal(d, value)
-    # m = mask_or(c, getmask(x))
-    # return array(d, mask=m, copy=copy)
     output = masked_where(equal(x, value), x, copy=copy)
     output.fill_value = value
     return output
@@ -2197,7 +2241,8 @@ def masked_values(x, value, rtol=1e-5, atol=1e-8, copy=True, shrink=True):
     mabs = umath.absolute
     xnew = filled(x, value)
     if issubclass(xnew.dtype.type, np.floating):
-        condition = umath.less_equal(mabs(xnew - value), atol + rtol * mabs(value))
+        condition = umath.less_equal(
+            mabs(xnew - value), atol + rtol * mabs(value))
         mask = getattr(x, '_mask', nomask)
     else:
         condition = umath.equal(xnew, value)
@@ -2248,49 +2293,68 @@ def masked_invalid(a, copy=True):
     return result
 
 
-#####--------------------------------------------------------------------------
-#---- --- Printing options ---
-#####--------------------------------------------------------------------------
+###############################################################################
+#                            Printing options                                 #
+###############################################################################
+
 
 class _MaskedPrintOption:
     """
     Handle the string used to represent missing data in a masked array.
 
     """
-    def __init__ (self, display):
-        "Create the masked_print_option object."
+
+    def __init__(self, display):
+        """
+        Create the masked_print_option object.
+
+        """
         self._display = display
         self._enabled = True
 
     def display(self):
-        "Display the string to print for masked values."
+        """
+        Display the string to print for masked values.
+
+        """
         return self._display
 
-    def set_display (self, s):
-        "Set the string to print for masked values."
+    def set_display(self, s):
+        """
+        Set the string to print for masked values.
+
+        """
         self._display = s
 
     def enabled(self):
-        "Is the use of the display value enabled?"
+        """
+        Is the use of the display value enabled?
+
+        """
         return self._enabled
 
     def enable(self, shrink=1):
-        "Set the enabling shrink to `shrink`."
+        """
+        Set the enabling shrink to `shrink`.
+
+        """
         self._enabled = shrink
 
-    def __str__ (self):
+    def __str__(self):
         return str(self._display)
 
     __repr__ = __str__
 
-#if you single index into a masked location you get this object.
+# if you single index into a masked location you get this object.
 masked_print_option = _MaskedPrintOption('--')
 
 
 def _recursive_printoption(result, mask, printopt):
     """
     Puts printoptions in result where mask is True.
+
     Private function allowing for recursion
+
     """
     names = result.dtype.names
     for name in names:
@@ -2328,14 +2392,15 @@ masked_%(name)s(data = %(data)s,
 %(nlen)s       dtype = %(dtype)s)
 """)
 
-#####--------------------------------------------------------------------------
-#---- --- MaskedArray class ---
-#####--------------------------------------------------------------------------
+###############################################################################
+#                          MaskedArray class                                  #
+###############################################################################
+
 
 def _recursive_filled(a, mask, fill_value):
     """
     Recursively fill `a` with `fill_value`.
-    Private function
+
     """
     names = a.dtype.names
     for name in names:
@@ -2346,7 +2411,6 @@ def _recursive_filled(a, mask, fill_value):
             np.copyto(current, fill_value[name], where=mask[name])
 
 
-
 def flatten_structured_array(a):
     """
     Flatten a structured array.
@@ -2373,16 +2437,19 @@ def flatten_structured_array(a):
            [2., 2.]])
 
     """
-    #
+
     def flatten_sequence(iterable):
-        """Flattens a compound of nested iterables."""
+        """
+        Flattens a compound of nested iterables.
+
+        """
         for elm in iter(iterable):
             if hasattr(elm, '__iter__'):
                 for f in flatten_sequence(elm):
                     yield f
             else:
                 yield elm
-    #
+
     a = np.asanyarray(a)
     inishape = a.shape
     a = a.ravel()
@@ -2400,7 +2467,6 @@ def flatten_structured_array(a):
     return out
 
 
-
 class _arraymethod(object):
     """
     Define a wrapper for basic array methods.
@@ -2430,27 +2496,29 @@ class _arraymethod(object):
         attribute.
 
     """
+
     def __init__(self, funcname, onmask=True):
         self.__name__ = funcname
         self._onmask = onmask
         self.obj = None
         self.__doc__ = self.getdoc()
-    #
+
     def getdoc(self):
         "Return the doc of the function (from the doc of the method)."
         methdoc = getattr(ndarray, self.__name__, None) or \
-                  getattr(np, self.__name__, None)
+            getattr(np, self.__name__, None)
         if methdoc is not None:
             return methdoc.__doc__
-    #
+
     def __get__(self, obj, objtype=None):
         self.obj = obj
         return self
-    #
+
     def __call__(self, *args, **params):
         methodname = self.__name__
         instance = self.obj
-        # Fallback : if the instance has not been initialized, use the first arg
+        # Fallback : if the instance has not been initialized, use the first
+        # arg
         if instance is None:
             args = list(args)
             instance = args.pop(0)
@@ -2517,10 +2585,11 @@ class MaskedIterator(object):
            fill_value = 999999)
 
     """
+
     def __init__(self, ma):
         self.ma = ma
         self.dataiter = ma._data.flat
-        #
+
         if ma._mask is nomask:
             self.maskiter = None
         else:
@@ -2543,7 +2612,7 @@ class MaskedIterator(object):
                 return masked
         return result
 
-    ### This won't work is ravel makes a copy
+    # This won't work if ravel makes a copy
     def __setitem__(self, index, value):
         self.dataiter[index] = getdata(value)
         if self.maskiter is not None:
@@ -2640,29 +2709,30 @@ class MaskedArray(ndarray):
                 keep_mask=True, hard_mask=None, shrink=True,
                 **options):
         """
-    Create a new masked array from scratch.
+        Create a new masked array from scratch.
 
-    Notes
-    -----
-    A masked array can also be created by taking a .view(MaskedArray).
+        Notes
+        -----
+        A masked array can also be created by taking a .view(MaskedArray).
 
         """
-        # Process data............
+        # Process data.
         _data = np.array(data, dtype=dtype, copy=copy, subok=True, ndmin=ndmin)
         _baseclass = getattr(data, '_baseclass', type(_data))
-        # Check that we're not erasing the mask..........
+        # Check that we're not erasing the mask.
         if isinstance(data, MaskedArray) and (data.shape != _data.shape):
             copy = True
-        # Careful, cls might not always be MaskedArray...
+        # Careful, cls might not always be MaskedArray.
         if not isinstance(data, cls) or not subok:
             _data = ndarray.view(_data, cls)
         else:
             _data = ndarray.view(_data, type(data))
-        # Backwards compatibility w/ numpy.core.ma .......
+        # Backwards compatibility w/ numpy.core.ma.
         if hasattr(data, '_mask') and not isinstance(data, ndarray):
             _data._mask = data._mask
+            # FIXME _sharedmask is never used.
             _sharedmask = True
-        # Process mask ...............................
+        # Process mask.
         # Number of named fields (or zero if none)
         names_ = _data.dtype.names or ()
         # Type of the mask
@@ -2670,9 +2740,10 @@ class MaskedArray(ndarray):
             mdtype = make_mask_descr(_data.dtype)
         else:
             mdtype = MaskType
-        # Case 1. : no mask in input ............
+
         if mask is nomask:
-             # Erase the current mask ?
+            # Case 1. : no mask in input.
+            # Erase the current mask ?
             if not keep_mask:
                 # With a reduced version
                 if shrink:
@@ -2702,15 +2773,15 @@ class MaskedArray(ndarray):
                         data._mask.shape = data.shape
                 else:
                     _data._sharedmask = True
-        # Case 2. : With a mask in input ........
         else:
+            # Case 2. : With a mask in input.
             # Read the mask with the current mdtype
             try:
                 mask = np.array(mask, copy=copy, dtype=mdtype)
             # Or assume it's a sequence of bool/int
             except TypeError:
                 mask = np.array([tuple([m] * len(mdtype)) for m in mask],
-                                 dtype=mdtype)
+                                dtype=mdtype)
             # Make sure the mask and the data have the same shape
             if mask.shape != _data.shape:
                 (nd, nm) = (_data.size, mask.size)
@@ -2746,10 +2817,10 @@ class MaskedArray(ndarray):
                     else:
                         _data._mask = np.logical_or(mask, _data._mask)
                     _data._sharedmask = False
-        # Update fill_value.......
+        # Update fill_value.
         if fill_value is None:
             fill_value = getattr(data, '_fill_value', None)
-        # But don't run the check unless we have something to check....
+        # But don't run the check unless we have something to check.
         if fill_value is not None:
             _data._fill_value = _check_fill_value(fill_value, _data.dtype)
         # Process extra options ..
@@ -2759,9 +2830,12 @@ class MaskedArray(ndarray):
             _data._hardmask = hard_mask
         _data._baseclass = _baseclass
         return _data
-    #
+
+
     def _update_from(self, obj):
-        """Copies some attributes of obj to self.
+        """
+        Copies some attributes of obj to self.
+
         """
         if obj is not None and isinstance(obj, ndarray):
             _baseclass = type(obj)
@@ -2784,19 +2858,21 @@ class MaskedArray(ndarray):
         self.__dict__.update(_optinfo)
         return
 
-
     def __array_finalize__(self, obj):
-        """Finalizes the masked array.
         """
-        # Get main attributes .........
+        Finalizes the masked array.
+
+        """
+        # Get main attributes.
         self._update_from(obj)
+
         # We have to decide how to initialize self.mask, based on
         # obj.mask. This is very difficult.  There might be some
         # correspondence between the elements in the array we are being
-        # created from (= obj) and us. Or... there might not. This method can
+        # created from (= obj) and us. Or there might not. This method can
         # be called in all kinds of places for all kinds of reasons -- could
-        # be empty_like, could be slicing, could be a ufunc, could be a view,
-        # ... The numpy subclassing interface simply doesn't give us any way
+        # be empty_like, could be slicing, could be a ufunc, could be a view.
+        # The numpy subclassing interface simply doesn't give us any way
         # to know, which means that at best this method will be based on
         # guesswork and heuristics. To make things worse, there isn't even any
         # clear consensus about what the desired behavior is. For instance,
@@ -2824,6 +2900,7 @@ class MaskedArray(ndarray):
                                 make_mask_none(obj.shape, obj.dtype))
             else:
                 _mask = getattr(obj, '_mask', nomask)
+
             # If self and obj point to exactly the same data, then probably
             # self is a simple view of obj (e.g., self = obj[...]), so they
             # should share the same mask. (This isn't 100% reliable, e.g. self
@@ -2837,7 +2914,7 @@ class MaskedArray(ndarray):
         else:
             _mask = nomask
         self._mask = _mask
-        # Finalize the mask ...........
+        # Finalize the mask
         if self._mask is not nomask:
             try:
                 self._mask.shape = self.shape
@@ -2852,20 +2929,21 @@ class MaskedArray(ndarray):
                 self._fill_value = _check_fill_value(None, self.dtype)
         return
 
-
     def __array_wrap__(self, obj, context=None):
         """
         Special hook for ufuncs.
+
         Wraps the numpy array and sets the mask according to context.
+
         """
         result = obj.view(type(self))
         result._update_from(self)
-        #..........
+
         if context is not None:
             result._mask = result._mask.copy()
             (func, args, _) = context
             m = reduce(mask_or, [getmaskarray(arg) for arg in args])
-            # Get the domain mask................
+            # Get the domain mask
             domain = ufunc_domain.get(func, None)
             if domain is not None:
                 # Take the domain, and make sure it's a ndarray
@@ -2898,9 +2976,8 @@ class MaskedArray(ndarray):
             else:
                 result._mask = m
                 result._sharedmask = False
-        #....
-        return result
 
+        return result
 
     def view(self, dtype=None, type=None, fill_value=None):
         """
@@ -2977,7 +3054,7 @@ class MaskedArray(ndarray):
         if getattr(output, '_fill_value', None) is not None:
             if fill_value is None:
                 if dtype is None:
-                    pass # leave _fill_value as is
+                    pass  # leave _fill_value as is
                 else:
                     output._fill_value = None
             else:
@@ -2985,7 +3062,6 @@ class MaskedArray(ndarray):
         return output
     view.__doc__ = ndarray.view.__doc__
 
-
     def astype(self, newtype):
         """
         Returns a copy of the MaskedArray cast to given newtype.
@@ -3025,33 +3101,29 @@ class MaskedArray(ndarray):
             output._fill_value = _check_fill_value(self._fill_value, newtype)
         return output
 
-
     def __getitem__(self, indx):
-        """x.__getitem__(y) <==> x[y]
+        """
+        x.__getitem__(y) <==> x[y]
 
         Return the item described by i, as a masked array.
 
         """
-        # This test is useful, but we should keep things light...
-#        if getmask(indx) is not nomask:
-#            msg = "Masked arrays must be filled before they can be used as indices!"
-#            raise IndexError(msg)
         dout = self.data[indx]
-        # We could directly use ndarray.__getitem__ on self...
+        # We could directly use ndarray.__getitem__ on self.
         # But then we would have to modify __array_finalize__ to prevent the
-        # mask of being reshaped if it hasn't been set up properly yet...
+        # mask of being reshaped if it hasn't been set up properly yet
         # So it's easier to stick to the current version
         _mask = self._mask
         # Did we extract a single item?
         if not getattr(dout, 'ndim', False):
-            # A record ................
+            # A record
             if isinstance(dout, np.void):
                 mask = _mask[indx]
                 # We should always re-cast to mvoid, otherwise users can
                 # change masks on rows that already have masked values, but not
                 # on rows that have no masked values, which is inconsistent.
                 dout = mvoid(dout, mask=mask, hardmask=self._hardmask)
-            # Just a scalar............
+            # Just a scalar
             elif _mask is not nomask and _mask[indx]:
                 return masked
         elif self.dtype.type is np.object_ and self.dtype is not dout.dtype:
@@ -3060,11 +3132,11 @@ class MaskedArray(ndarray):
             if _mask is not nomask and _mask[indx]:
                 return MaskedArray(dout, mask=True)
         else:
-            # Force dout to MA ........
+            # Force dout to MA
             dout = dout.view(type(self))
             # Inherit attributes from self
             dout._update_from(self)
-            # Check the fill_value ....
+            # Check the fill_value
             if isinstance(indx, basestring):
                 if self._fill_value is not None:
                     dout._fill_value = self._fill_value[indx]
@@ -3075,11 +3147,12 @@ class MaskedArray(ndarray):
                 # set shape to match that of data; this is needed for matrices
                 dout._mask.shape = dout.shape
                 dout._sharedmask = True
-#               Note: Don't try to check for m.any(), that'll take too long...
+                # Note: Don't try to check for m.any(), that'll take too long
         return dout
 
     def __setitem__(self, indx, value):
-        """x.__setitem__(i, y) <==> x[i]=y
+        """
+        x.__setitem__(i, y) <==> x[i]=y
 
         Set item described by index. If value is masked, masks those
         locations.
@@ -3087,10 +3160,6 @@ class MaskedArray(ndarray):
         """
         if self is masked:
             raise MaskError('Cannot alter the masked element.')
-        # This test is useful, but we should keep things light...
-#        if getmask(indx) is not nomask:
-#            msg = "Masked arrays must be filled before they can be used as indices!"
-#            raise IndexError(msg)
         _data = self._data
         _mask = self._mask
         if isinstance(indx, basestring):
@@ -3099,12 +3168,12 @@ class MaskedArray(ndarray):
                 self._mask = _mask = make_mask_none(self.shape, self.dtype)
             _mask[indx] = getmask(value)
             return
-        #........................................
+
         _dtype = _data.dtype
         nbfields = len(_dtype.names or ())
-        #........................................
+
         if value is masked:
-            # The mask wasn't set: create a full version...
+            # The mask wasn't set: create a full version.
             if _mask is nomask:
                 _mask = self._mask = make_mask_none(self.shape, _dtype)
             # Now, set the mask to its value.
@@ -3115,7 +3184,7 @@ class MaskedArray(ndarray):
             if not self._isfield:
                 self._sharedmask = False
             return
-        #........................................
+
         # Get the _data part of the new value
         dval = value
         # Get the _mask part of the new value
@@ -3141,7 +3210,7 @@ class MaskedArray(ndarray):
             _data[indx] = dval
         else:
             if nbfields:
-                err_msg = "Flexible 'hard' masks are not yet supported..."
+                err_msg = "Flexible 'hard' masks are not yet supported."
                 raise NotImplementedError(err_msg)
             mindx = mask_or(_mask[indx], mval, copy=True)
             dindx = self._data[indx]
@@ -3157,7 +3226,6 @@ class MaskedArray(ndarray):
         super(MaskedArray, self).__setattr__(attr, value)
         if attr == 'dtype' and self._mask is not nomask:
             self._mask = self._mask.view(make_mask_descr(value), ndarray)
-
             # Try to reset the shape of the mask (if we don't have a void)
             # This raises a ValueError if the dtype change won't work
             try:
@@ -3166,60 +3234,64 @@ class MaskedArray(ndarray):
                 pass
 
     def __getslice__(self, i, j):
-        """x.__getslice__(i, j) <==> x[i:j]
+        """
+        x.__getslice__(i, j) <==> x[i:j]
 
-        Return the slice described by (i, j).  The use of negative
-        indices is not supported.
+        Return the slice described by (i, j).  The use of negative indices
+        is not supported.
 
         """
         return self.__getitem__(slice(i, j))
 
     def __setslice__(self, i, j, value):
-        """x.__setslice__(i, j, value) <==> x[i:j]=value
+        """
+        x.__setslice__(i, j, value) <==> x[i:j]=value
 
-    Set the slice (i,j) of a to value. If value is masked, mask
-    those locations.
+        Set the slice (i,j) of a to value. If value is masked, mask those
+        locations.
 
         """
         self.__setitem__(slice(i, j), value)
 
-
     def __setmask__(self, mask, copy=False):
-        """Set the mask.
+        """
+        Set the mask.
 
         """
         idtype = self.dtype
         current_mask = self._mask
         if mask is masked:
             mask = True
-        # Make sure the mask is set
+
         if (current_mask is nomask):
-            # Just don't do anything is there's nothing to do...
+            # Make sure the mask is set
+            # Just don't do anything if there's nothing to do.
             if mask is nomask:
                 return
             current_mask = self._mask = make_mask_none(self.shape, idtype)
-        # No named fields.........
+
         if idtype.names is None:
+            # No named fields.
             # Hardmask: don't unmask the data
             if self._hardmask:
                 current_mask |= mask
             # Softmask: set everything to False
             # If it's obviously a compatible scalar, use a quick update
-            # method...
+            # method.
             elif isinstance(mask, (int, float, np.bool_, np.number)):
                 current_mask[...] = mask
-            # ...otherwise fall back to the slower, general purpose way.
+            # Otherwise fall back to the slower, general purpose way.
             else:
                 current_mask.flat = mask
-        # Named fields w/ ............
         else:
+            # Named fields w/
             mdtype = current_mask.dtype
             mask = np.array(mask, copy=False)
             # Mask is a singleton
             if not mask.ndim:
                 # It's a boolean : make a record
                 if mask.dtype.kind == 'b':
-                    mask = np.array(tuple([mask.item()]*len(mdtype)),
+                    mask = np.array(tuple([mask.item()] * len(mdtype)),
                                     dtype=mdtype)
                 # It's a record: make sure the dtype is correct
                 else:
@@ -3239,49 +3311,52 @@ class MaskedArray(ndarray):
                     current_mask[n] |= mask[n]
             # Softmask: set everything to False
             # If it's obviously a compatible scalar, use a quick update
-            # method...
+            # method.
             elif isinstance(mask, (int, float, np.bool_, np.number)):
                 current_mask[...] = mask
-            # ...otherwise fall back to the slower, general purpose way.
+            # Otherwise fall back to the slower, general purpose way.
             else:
                 current_mask.flat = mask
         # Reshape if needed
         if current_mask.shape:
             current_mask.shape = self.shape
         return
+
     _set_mask = __setmask__
-    #....
+
     def _get_mask(self):
         """Return the current mask.
 
         """
-        # We could try to force a reshape, but that wouldn't work in some cases.
-#        return self._mask.reshape(self.shape)
+        # We could try to force a reshape, but that wouldn't work in some
+        # cases.
         return self._mask
-    mask = property(fget=_get_mask, fset=__setmask__, doc="Mask")
 
+    mask = property(fget=_get_mask, fset=__setmask__, doc="Mask")
 
     def _get_recordmask(self):
         """
-    Return the mask of the records.
-    A record is masked when all the fields are masked.
+        Return the mask of the records.
+
+        A record is masked when all the fields are masked.
 
         """
         _mask = self._mask.view(ndarray)
         if _mask.dtype.names is None:
             return _mask
-        return np.all(flatten_structured_array(_mask), axis= -1)
-
+        return np.all(flatten_structured_array(_mask), axis=-1)
 
     def _set_recordmask(self):
-        """Return the mask of the records.
-    A record is masked when all the fields are masked.
+        """
+        Return the mask of the records.
+
+        A record is masked when all the fields are masked.
 
         """
         raise NotImplementedError("Coming soon: setting the mask per records!")
+
     recordmask = property(fget=_get_recordmask)
 
-    #............................................
     def harden_mask(self):
         """
         Force the mask to hard.
@@ -3315,7 +3390,6 @@ class MaskedArray(ndarray):
     hardmask = property(fget=lambda self: self._hardmask,
                         doc="Hardness of the mask")
 
-
     def unshare_mask(self):
         """
         Copy the mask and set the sharedmask flag to False.
@@ -3365,9 +3439,7 @@ class MaskedArray(ndarray):
             self._mask = nomask
         return self
 
-    #............................................
-
-    baseclass = property(fget=lambda self:self._baseclass,
+    baseclass = property(fget=lambda self: self._baseclass,
                          doc="Class of the underlying data (read-only).")
 
     def _get_data(self):
@@ -3376,22 +3448,22 @@ class MaskedArray(ndarray):
 
         """
         return ndarray.view(self, self._baseclass)
+
     _data = property(fget=_get_data)
     data = property(fget=_get_data)
 
     def _get_flat(self):
         "Return a flat iterator."
         return MaskedIterator(self)
-    #
-    def _set_flat (self, value):
+
+    def _set_flat(self, value):
         "Set a flattened version of self to value."
         y = self.ravel()
         y[:] = value
-    #
+
     flat = property(fget=_get_flat, fset=_set_flat,
                     doc="Flat version of the array.")
 
-
     def get_fill_value(self):
         """
         Return the filling value of the masked array.
@@ -3462,7 +3534,6 @@ class MaskedArray(ndarray):
     fill_value = property(fget=get_fill_value, fset=set_fill_value,
                           doc="Filling value.")
 
-
     def filled(self, fill_value=None):
         """
         Return a copy of self, with masked values filled with a given value.
@@ -3503,15 +3574,15 @@ class MaskedArray(ndarray):
         m = self._mask
         if m is nomask:
             return self._data
-        #
+
         if fill_value is None:
             fill_value = self.fill_value
         else:
             fill_value = _check_fill_value(fill_value, self.dtype)
-        #
+
         if self is masked_singleton:
             return np.asanyarray(fill_value)
-        #
+
         if m.dtype.names:
             result = self._data.copy('K')
             _recursive_filled(result, self._mask, fill_value)
@@ -3526,7 +3597,7 @@ class MaskedArray(ndarray):
                 d = result.astype(object)
                 result = np.choose(m, (d, fill_value))
             except IndexError:
-                #ok, if scalar
+                # ok, if scalar
                 if self._data.shape:
                     raise
                 elif m:
@@ -3562,7 +3633,6 @@ class MaskedArray(ndarray):
             data = data.compress(np.logical_not(ndarray.ravel(self._mask)))
         return data
 
-
     def compress(self, condition, axis=None, out=None):
         """
         Return `a` where condition is ``True``.
@@ -3620,18 +3690,20 @@ class MaskedArray(ndarray):
         """
         # Get the basic components
         (_data, _mask) = (self._data, self._mask)
-        # Force the condition to a regular ndarray (forget the missing values...)
+
+        # Force the condition to a regular ndarray and forget the missing
+        # values.
         condition = np.array(condition, copy=False, subok=False)
-        #
+
         _new = _data.compress(condition, axis=axis, out=out).view(type(self))
         _new._update_from(self)
         if _mask is not nomask:
             _new._mask = _mask.compress(condition, axis=axis)
         return _new
 
-    #............................................
     def __str__(self):
-        """String representation.
+        """
+        String representation.
 
         """
         if masked_print_option.enabled():
@@ -3668,7 +3740,8 @@ class MaskedArray(ndarray):
         return str(res)
 
     def __repr__(self):
-        """Literal string representation.
+        """
+        Literal string representation.
 
         """
         n = len(self.shape)
@@ -3690,16 +3763,19 @@ class MaskedArray(ndarray):
 
     def _delegate_binop(self, other):
         # This emulates the logic in
-        #     multiarray/number.c:PyArray_GenericBinaryFunction
+        # multiarray/number.c:PyArray_GenericBinaryFunction
         if (not isinstance(other, np.ndarray)
-            and not hasattr(other, "__numpy_ufunc__")):
+                and not hasattr(other, "__numpy_ufunc__")):
             other_priority = getattr(other, "__array_priority__", -1000000)
             if self.__array_priority__ < other_priority:
                 return True
         return False
 
     def __eq__(self, other):
-        "Check whether other equals self elementwise"
+        """
+        Check whether other equals self elementwise.
+
+        """
         if self is masked:
             return masked
         omask = getattr(other, '_mask', nomask)
@@ -3727,12 +3803,15 @@ class MaskedArray(ndarray):
                         mask = mask.view((bool_, len(self.dtype))).all(axis)
                     except ValueError:
                         mask = np.all([[f[n].all() for n in mask.dtype.names]
-                                        for f in mask], axis=axis)
+                                       for f in mask], axis=axis)
                 check._mask = mask
         return check
-    #
+
     def __ne__(self, other):
-        "Check whether other doesn't equal self elementwise"
+        """
+        Check whether other doesn't equal self elementwise
+
+        """
         if self is masked:
             return masked
         omask = getattr(other, '_mask', nomask)
@@ -3760,82 +3839,121 @@ class MaskedArray(ndarray):
                         mask = mask.view((bool_, len(self.dtype))).all(axis)
                     except ValueError:
                         mask = np.all([[f[n].all() for n in mask.dtype.names]
-                                        for f in mask], axis=axis)
+                                       for f in mask], axis=axis)
                 check._mask = mask
         return check
-    #
+
     def __add__(self, other):
-        "Add self to other, and return a new masked array."
+        """
+        Add self to other, and return a new masked array.
+
+        """
         if self._delegate_binop(other):
             return NotImplemented
         return add(self, other)
-    #
+
     def __radd__(self, other):
-        "Add other to self, and return a new masked array."
+        """
+        Add other to self, and return a new masked array.
+
+        """
         # In analogy with __rsub__ and __rdiv__, use original order:
         # we get here from `other + self`.
         return add(other, self)
-    #
+
     def __sub__(self, other):
-        "Subtract other from self, and return a new masked array."
+        """
+        Subtract other from self, and return a new masked array.
+
+        """
         if self._delegate_binop(other):
             return NotImplemented
         return subtract(self, other)
-    #
+
     def __rsub__(self, other):
-        "Subtract self from other, and return a new masked array."
+        """
+        Subtract self from other, and return a new masked array.
+
+        """
         return subtract(other, self)
-    #
+
     def __mul__(self, other):
         "Multiply self by other, and return a new masked array."
         if self._delegate_binop(other):
             return NotImplemented
         return multiply(self, other)
-    #
+
     def __rmul__(self, other):
-        "Multiply other by self, and return a new masked array."
+        """
+        Multiply other by self, and return a new masked array.
+
+        """
         # In analogy with __rsub__ and __rdiv__, use original order:
         # we get here from `other * self`.
         return multiply(other, self)
-    #
+
     def __div__(self, other):
-        "Divide other into self, and return a new masked array."
+        """
+        Divide other into self, and return a new masked array.
+
+        """
         if self._delegate_binop(other):
             return NotImplemented
         return divide(self, other)
-    #
+
     def __truediv__(self, other):
-        "Divide other into self, and return a new masked array."
+        """
+        Divide other into self, and return a new masked array.
+
+        """
         if self._delegate_binop(other):
             return NotImplemented
         return true_divide(self, other)
-    #
+
     def __rtruediv__(self, other):
-        "Divide self into other, and return a new masked array."
+        """
+        Divide self into other, and return a new masked array.
+
+        """
         return true_divide(other, self)
-    #
+
     def __floordiv__(self, other):
-        "Divide other into self, and return a new masked array."
+        """
+        Divide other into self, and return a new masked array.
+
+        """
         if self._delegate_binop(other):
             return NotImplemented
         return floor_divide(self, other)
-    #
+
     def __rfloordiv__(self, other):
-        "Divide self into other, and return a new masked array."
+        """
+        Divide self into other, and return a new masked array.
+
+        """
         return floor_divide(other, self)
-    #
+
     def __pow__(self, other):
-        "Raise self to the power other, masking the potential NaNs/Infs"
+        """
+        Raise self to the power other, masking the potential NaNs/Infs
+
+        """
         if self._delegate_binop(other):
             return NotImplemented
         return power(self, other)
-    #
+
     def __rpow__(self, other):
-        "Raise other to the power self, masking the potential NaNs/Infs"
+        """
+        Raise other to the power self, masking the potential NaNs/Infs
+
+        """
         return power(other, self)
-    #............................................
+
     def __iadd__(self, other):
-        "Add other to self in-place."
+        """
+        Add other to self in-place.
+
+        """
         m = getmask(other)
         if self._mask is nomask:
             if m is not nomask and m.any():
@@ -3847,9 +3965,12 @@ class MaskedArray(ndarray):
         self._data.__iadd__(np.where(self._mask, self.dtype.type(0),
                                      getdata(other)))
         return self
-    #....
+
     def __isub__(self, other):
-        "Subtract other from self in-place."
+        """
+        Subtract other from self in-place.
+
+        """
         m = getmask(other)
         if self._mask is nomask:
             if m is not nomask and m.any():
@@ -3860,9 +3981,12 @@ class MaskedArray(ndarray):
         self._data.__isub__(np.where(self._mask, self.dtype.type(0),
                                      getdata(other)))
         return self
-    #....
+
     def __imul__(self, other):
-        "Multiply self by other in-place."
+        """
+        Multiply self by other in-place.
+
+        """
         m = getmask(other)
         if self._mask is nomask:
             if m is not nomask and m.any():
@@ -3873,9 +3997,12 @@ class MaskedArray(ndarray):
         self._data.__imul__(np.where(self._mask, self.dtype.type(1),
                                      getdata(other)))
         return self
-    #....
+
     def __idiv__(self, other):
-        "Divide self by other in-place."
+        """
+        Divide self by other in-place.
+
+        """
         other_data = getdata(other)
         dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
         other_mask = getmask(other)
@@ -3884,14 +4011,16 @@ class MaskedArray(ndarray):
         if dom_mask.any():
             (_, fval) = ufunc_fills[np.divide]
             other_data = np.where(dom_mask, fval, other_data)
-#        self._mask = mask_or(self._mask, new_mask)
         self._mask |= new_mask
         self._data.__idiv__(np.where(self._mask, self.dtype.type(1),
                                      other_data))
         return self
-    #....
+
     def __ifloordiv__(self, other):
-        "Floor divide self by other in-place."
+        """
+        Floor divide self by other in-place.
+
+        """
         other_data = getdata(other)
         dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
         other_mask = getmask(other)
@@ -3900,14 +4029,16 @@ class MaskedArray(ndarray):
         if dom_mask.any():
             (_, fval) = ufunc_fills[np.floor_divide]
             other_data = np.where(dom_mask, fval, other_data)
-#        self._mask = mask_or(self._mask, new_mask)
         self._mask |= new_mask
         self._data.__ifloordiv__(np.where(self._mask, self.dtype.type(1),
                                           other_data))
         return self
-    #....
+
     def __itruediv__(self, other):
-        "True divide self by other in-place."
+        """
+        True divide self by other in-place.
+
+        """
         other_data = getdata(other)
         dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
         other_mask = getmask(other)
@@ -3916,14 +4047,16 @@ class MaskedArray(ndarray):
         if dom_mask.any():
             (_, fval) = ufunc_fills[np.true_divide]
             other_data = np.where(dom_mask, fval, other_data)
-#        self._mask = mask_or(self._mask, new_mask)
         self._mask |= new_mask
         self._data.__itruediv__(np.where(self._mask, self.dtype.type(1),
                                          other_data))
         return self
-    #...
+
     def __ipow__(self, other):
-        "Raise self to the power other, in place."
+        """
+        Raise self to the power other, in place.
+
+        """
         other_data = getdata(other)
         other_mask = getmask(other)
         with np.errstate(divide='ignore', invalid='ignore'):
@@ -3939,9 +4072,12 @@ class MaskedArray(ndarray):
         new_mask = mask_or(other_mask, invalid)
         self._mask = mask_or(self._mask, new_mask)
         return self
-    #............................................
+
     def __float__(self):
-        "Convert to float."
+        """
+        Convert to float.
+
+        """
         if self.size > 1:
             raise TypeError("Only length-1 arrays can be converted "
                             "to Python scalars")
@@ -3951,7 +4087,10 @@ class MaskedArray(ndarray):
         return float(self.item())
 
     def __int__(self):
-        "Convert to int."
+        """
+        Convert to int.
+
+        """
         if self.size > 1:
             raise TypeError("Only length-1 arrays can be converted "
                             "to Python scalars")
@@ -3959,7 +4098,6 @@ class MaskedArray(ndarray):
             raise MaskError('Cannot convert masked element to a Python int.')
         return int(self.item())
 
-
     def get_imag(self):
         """
         Return the imaginary part of the masked array.
@@ -3992,6 +4130,7 @@ class MaskedArray(ndarray):
         result = self._data.imag.view(type(self))
         result.__setmask__(self._mask)
         return result
+
     imag = property(fget=get_imag, doc="Imaginary part.")
 
     def get_real(self):
@@ -4028,8 +4167,6 @@ class MaskedArray(ndarray):
         return result
     real = property(fget=get_real, doc="Real part")
 
-
-    #............................................
     def count(self, axis=None):
         """
         Count the non-masked elements of the array along the given axis.
@@ -4092,9 +4229,9 @@ class MaskedArray(ndarray):
             return (n1 - n2)
         else:
             return narray(n1 - n2)
-    #............................................
+
     flatten = _arraymethod('flatten')
-    #
+
     def ravel(self, order='C'):
         """
         Returns a 1D version of self, as a view.
@@ -4139,10 +4276,11 @@ class MaskedArray(ndarray):
         else:
             r._mask = nomask
         return r
-    #
+
     repeat = _arraymethod('repeat')
-    #
-    def reshape (self, *s, **kwargs):
+
+
+    def reshape(self, *s, **kwargs):
         """
         Give a new shape to the array without changing its data.
 
@@ -4197,7 +4335,7 @@ class MaskedArray(ndarray):
         if mask is not nomask:
             result._mask = mask.reshape(*s, **kwargs)
         return result
-    #
+
     def resize(self, newshape, refcheck=True, order=False):
         """
         .. warning::
@@ -4211,20 +4349,11 @@ class MaskedArray(ndarray):
 
         """
         # Note : the 'order' keyword looks broken, let's just drop it
-#        try:
-#            ndarray.resize(self, newshape, refcheck=refcheck)
-#            if self.mask is not nomask:
-#                self._mask.resize(newshape, refcheck=refcheck)
-#        except ValueError:
-#            raise ValueError("Cannot resize an array that has been referenced "
-#                             "or is referencing another array in this way.\n"
-#                             "Use the numpy.ma.resize function.")
-#        return None
         errmsg = "A masked array does not own its data "\
                  "and therefore cannot be resized.\n" \
                  "Use the numpy.ma.resize function instead."
         raise ValueError(errmsg)
-    #
+
     def put(self, indices, values, mode='raise'):
         """
         Set storage-indexed locations to corresponding values.
@@ -4279,9 +4408,9 @@ class MaskedArray(ndarray):
             values.resize(indices.shape)
             indices = indices[~mask]
             values = values[~mask]
-        #....
+
         self._data.put(indices, values, mode=mode)
-        #....
+
         if m is nomask:
             m = getmask(values)
         else:
@@ -4292,8 +4421,8 @@ class MaskedArray(ndarray):
                 m.put(indices, values._mask, mode=mode)
             m = make_mask(m, copy=False, shrink=True)
         self._mask = m
-    #............................................
-    def ids (self):
+
+    def ids(self):
         """
         Return the addresses of the data and mask areas.
 
@@ -4346,37 +4475,36 @@ class MaskedArray(ndarray):
         """
         return self.flags['CONTIGUOUS']
 
-    #............................................
     def all(self, axis=None, out=None):
         """
-    Check if all of the elements of `a` are true.
+        Check if all of the elements of `a` are true.
 
-    Performs a :func:`logical_and` over the given axis and returns the result.
-    Masked values are considered as True during computation.
-    For convenience, the output array is masked where ALL the values along the
-    current axis are masked: if the output would have been a scalar and that
-    all the values are masked, then the output is `masked`.
+        Performs a :func:`logical_and` over the given axis and returns the result.
+        Masked values are considered as True during computation.
+        For convenience, the output array is masked where ALL the values along the
+        current axis are masked: if the output would have been a scalar and that
+        all the values are masked, then the output is `masked`.
 
-    Parameters
-    ----------
-    axis : {None, integer}
-        Axis to perform the operation over.
-        If None, perform over flattened array.
-    out : {None, array}, optional
-        Array into which the result can be placed. Its type is preserved
-        and it must be of the right shape to hold the output.
+        Parameters
+        ----------
+        axis : {None, integer}
+            Axis to perform the operation over.
+            If None, perform over flattened array.
+        out : {None, array}, optional
+            Array into which the result can be placed. Its type is preserved
+            and it must be of the right shape to hold the output.
 
-    See Also
-    --------
-    all : equivalent function
+        See Also
+        --------
+        all : equivalent function
 
-    Examples
-    --------
-    >>> np.ma.array([1,2,3]).all()
-    True
-    >>> a = np.ma.array([1,2,3], mask=True)
-    >>> (a.all() is np.ma.masked)
-    True
+        Examples
+        --------
+        >>> np.ma.array([1,2,3]).all()
+        True
+        >>> a = np.ma.array([1,2,3], mask=True)
+        >>> (a.all() is np.ma.masked)
+        True
 
         """
         mask = _check_mask_axis(self._mask, axis)
@@ -4393,7 +4521,6 @@ class MaskedArray(ndarray):
                 out.__setmask__(mask)
         return out
 
-
     def any(self, axis=None, out=None):
         """
         Check if any of the elements of `a` are true.
@@ -4429,7 +4556,6 @@ class MaskedArray(ndarray):
                 out.__setmask__(mask)
         return out
 
-
     def nonzero(self):
         """
         Return the indices of unmasked elements that are not zero.
@@ -4531,7 +4657,6 @@ class MaskedArray(ndarray):
         """
         return narray(self.filled(0), copy=False).nonzero()
 
-
     def trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None):
         """
         (this docstring should be overwritten)
@@ -4560,13 +4685,12 @@ class MaskedArray(ndarray):
             return r
         d = self.filled(0).dot(other.filled(0), out._data)
         if out.mask.shape != d.shape:
-            out._mask = numpy.empty(d.shape, MaskType)
+            out._mask = np.empty(d.shape, MaskType)
         np.dot(am, bm, out._mask)
         np.logical_not(out._mask, out._mask)
         return out
     dot.__doc__ = ndarray.dot.__doc__
 
-
     def sum(self, axis=None, dtype=None, out=None):
         """
         Return the sum of the array elements over the given axis.
@@ -4634,7 +4758,6 @@ class MaskedArray(ndarray):
             outmask.flat = newmask
         return out
 
-
     def cumsum(self, axis=None, dtype=None, out=None):
         """
         Return the cumulative sum of the elements along the given axis.
@@ -4691,7 +4814,6 @@ class MaskedArray(ndarray):
         result.__setmask__(self._mask)
         return result
 
-
     def prod(self, axis=None, dtype=None, out=None):
         """
         Return the product of the array elements over the given axis.
@@ -4813,7 +4935,6 @@ class MaskedArray(ndarray):
         result.__setmask__(self._mask)
         return result
 
-
     def mean(self, axis=None, dtype=None, out=None):
         """
         Returns the average of the array elements.
@@ -4939,7 +5060,7 @@ class MaskedArray(ndarray):
             dvar._mask = mask_or(self._mask.all(axis), (cnt <= 0))
             dvar._update_from(self)
         elif getattr(dvar, '_mask', False):
-        # Make sure that masked is returned when the scalar is masked.
+            # Make sure that masked is returned when the scalar is masked.
             dvar = masked
             if out is not None:
                 if isinstance(out, MaskedArray):
@@ -4963,7 +5084,6 @@ class MaskedArray(ndarray):
         return dvar
     var.__doc__ = np.var.__doc__
 
-
     def std(self, axis=None, dtype=None, out=None, ddof=0):
         ""
         dvar = self.var(axis=axis, dtype=dtype, out=out, ddof=ddof)
@@ -4975,7 +5095,6 @@ class MaskedArray(ndarray):
         return dvar
     std.__doc__ = np.std.__doc__
 
-    #............................................
     def round(self, decimals=0, out=None):
         """
         Return an array rounded a to the given number of decimals.
@@ -4998,7 +5117,6 @@ class MaskedArray(ndarray):
         return out
     round.__doc__ = ndarray.round.__doc__
 
-    #............................................
     def argsort(self, axis=None, kind='quicksort', order=None, fill_value=None):
         """
         Return an ndarray of indices that sort the array along the
@@ -5052,7 +5170,6 @@ class MaskedArray(ndarray):
         d = self.filled(fill_value).view(ndarray)
         return d.argsort(axis=axis, kind=kind, order=order)
 
-
     def argmin(self, axis=None, fill_value=None, out=None):
         """
         Return array of indices to the minimum values along the given axis.
@@ -5094,7 +5211,6 @@ class MaskedArray(ndarray):
         d = self.filled(fill_value).view(ndarray)
         return d.argmin(axis, out=out)
 
-
     def argmax(self, axis=None, fill_value=None, out=None):
         """
         Returns array of indices of the maximum values along the given axis.
@@ -5132,71 +5248,70 @@ class MaskedArray(ndarray):
         d = self.filled(fill_value).view(ndarray)
         return d.argmax(axis, out=out)
 
-
-    def sort(self, axis= -1, kind='quicksort', order=None,
+    def sort(self, axis=-1, kind='quicksort', order=None,
              endwith=True, fill_value=None):
         """
-    Sort the array, in-place
+        Sort the array, in-place
 
-    Parameters
-    ----------
-    a : array_like
-        Array to be sorted.
-    axis : int, optional
-        Axis along which to sort. If None, the array is flattened before
-        sorting. The default is -1, which sorts along the last axis.
-    kind : {'quicksort', 'mergesort', 'heapsort'}, optional
-        Sorting algorithm. Default is 'quicksort'.
-    order : list, optional
-        When `a` is a structured array, this argument specifies which fields
-        to compare first, second, and so on.  This list does not need to
-        include all of the fields.
-    endwith : {True, False}, optional
-        Whether missing values (if any) should be forced in the upper indices
-        (at the end of the array) (True) or lower indices (at the beginning).
-        When the array contains unmasked values of the largest (or smallest if
-        False) representable value of the datatype the ordering of these values
-        and the masked values is undefined.  To enforce the masked values are
-        at the end (beginning) in this case one must sort the mask.
-    fill_value : {var}, optional
-        Value used internally for the masked values.
-        If ``fill_value`` is not None, it supersedes ``endwith``.
-
-    Returns
-    -------
-    sorted_array : ndarray
-        Array of the same type and shape as `a`.
-
-    See Also
-    --------
-    ndarray.sort : Method to sort an array in-place.
-    argsort : Indirect sort.
-    lexsort : Indirect stable sort on multiple keys.
-    searchsorted : Find elements in a sorted array.
+        Parameters
+        ----------
+        a : array_like
+            Array to be sorted.
+        axis : int, optional
+            Axis along which to sort. If None, the array is flattened before
+            sorting. The default is -1, which sorts along the last axis.
+        kind : {'quicksort', 'mergesort', 'heapsort'}, optional
+            Sorting algorithm. Default is 'quicksort'.
+        order : list, optional
+            When `a` is a structured array, this argument specifies which fields
+            to compare first, second, and so on.  This list does not need to
+            include all of the fields.
+        endwith : {True, False}, optional
+            Whether missing values (if any) should be forced in the upper indices
+            (at the end of the array) (True) or lower indices (at the beginning).
+            When the array contains unmasked values of the largest (or smallest if
+            False) representable value of the datatype the ordering of these values
+            and the masked values is undefined.  To enforce the masked values are
+            at the end (beginning) in this case one must sort the mask.
+        fill_value : {var}, optional
+            Value used internally for the masked values.
+            If ``fill_value`` is not None, it supersedes ``endwith``.
 
-    Notes
-    -----
-    See ``sort`` for notes on the different sorting algorithms.
+        Returns
+        -------
+        sorted_array : ndarray
+            Array of the same type and shape as `a`.
 
-    Examples
-    --------
-    >>> a = ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
-    >>> # Default
-    >>> a.sort()
-    >>> print a
-    [1 3 5 -- --]
+        See Also
+        --------
+        ndarray.sort : Method to sort an array in-place.
+        argsort : Indirect sort.
+        lexsort : Indirect stable sort on multiple keys.
+        searchsorted : Find elements in a sorted array.
 
-    >>> a = ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
-    >>> # Put missing values in the front
-    >>> a.sort(endwith=False)
-    >>> print a
-    [-- -- 1 3 5]
+        Notes
+        -----
+        See ``sort`` for notes on the different sorting algorithms.
 
-    >>> a = ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
-    >>> # fill_value takes over endwith
-    >>> a.sort(endwith=False, fill_value=3)
-    >>> print a
-    [1 -- -- 3 5]
+        Examples
+        --------
+        >>> a = ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
+        >>> # Default
+        >>> a.sort()
+        >>> print a
+        [1 3 5 -- --]
+
+        >>> a = ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
+        >>> # Put missing values in the front
+        >>> a.sort(endwith=False)
+        >>> print a
+        [-- -- 1 3 5]
+
+        >>> a = ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
+        >>> # fill_value takes over endwith
+        >>> a.sort(endwith=False, fill_value=3)
+        >>> print a
+        [1 -- -- 3 5]
 
         """
         if self._mask is nomask:
@@ -5231,33 +5346,32 @@ class MaskedArray(ndarray):
             self._mask.flat = tmp_mask
         return
 
-    #............................................
     def min(self, axis=None, out=None, fill_value=None):
         """
-    Return the minimum along a given axis.
+        Return the minimum along a given axis.
 
-    Parameters
-    ----------
-    axis : {None, int}, optional
-        Axis along which to operate.  By default, ``axis`` is None and the
-        flattened input is used.
-    out : array_like, optional
-        Alternative output array in which to place the result.  Must be of
-        the same shape and buffer length as the expected output.
-    fill_value : {var}, optional
-        Value used to fill in the masked values.
-        If None, use the output of `minimum_fill_value`.
+        Parameters
+        ----------
+        axis : {None, int}, optional
+            Axis along which to operate.  By default, ``axis`` is None and the
+            flattened input is used.
+        out : array_like, optional
+            Alternative output array in which to place the result.  Must be of
+            the same shape and buffer length as the expected output.
+        fill_value : {var}, optional
+            Value used to fill in the masked values.
+            If None, use the output of `minimum_fill_value`.
 
-    Returns
-    -------
-    amin : array_like
-        New array holding the result.
-        If ``out`` was specified, ``out`` is returned.
+        Returns
+        -------
+        amin : array_like
+            New array holding the result.
+            If ``out`` was specified, ``out`` is returned.
 
-    See Also
-    --------
-    minimum_fill_value
-        Returns the minimum filling value for a given datatype.
+        See Also
+        --------
+        minimum_fill_value
+            Returns the minimum filling value for a given datatype.
 
         """
         _mask = self._mask
@@ -5266,7 +5380,8 @@ class MaskedArray(ndarray):
             fill_value = minimum_fill_value(self)
         # No explicit output
         if out is None:
-            result = self.filled(fill_value).min(axis=axis, out=out).view(type(self))
+            result = self.filled(fill_value).min(
+                axis=axis, out=out).view(type(self))
             if result.ndim:
                 # Set the mask
                 result.__setmask__(newmask)
@@ -5330,7 +5445,6 @@ class MaskedArray(ndarray):
         else:
             return minimum.reduce(self, axis)
 
-    #........................
     def max(self, axis=None, out=None, fill_value=None):
         """
         Return the maximum along a given axis.
@@ -5365,7 +5479,8 @@ class MaskedArray(ndarray):
             fill_value = maximum_fill_value(self)
         # No explicit output
         if out is None:
-            result = self.filled(fill_value).max(axis=axis, out=out).view(type(self))
+            result = self.filled(fill_value).max(
+                axis=axis, out=out).view(type(self))
             if result.ndim:
                 # Set the mask
                 result.__setmask__(newmask)
@@ -5448,17 +5563,16 @@ class MaskedArray(ndarray):
             out.__setmask__(outmask)
         return out
 
-
-    # Array methods ---------------------------------------
+    # Array methods
     copy = _arraymethod('copy')
     diagonal = _arraymethod('diagonal')
     transpose = _arraymethod('transpose')
-    T = property(fget=lambda self:self.transpose())
+    T = property(fget=lambda self: self.transpose())
     swapaxes = _arraymethod('swapaxes')
     clip = _arraymethod('clip', onmask=False)
     copy = _arraymethod('copy')
     squeeze = _arraymethod('squeeze')
-    #--------------------------------------------
+
     def tolist(self, fill_value=None):
         """
         Return the data portion of the masked array as a hierarchical Python list.
@@ -5493,48 +5607,23 @@ class MaskedArray(ndarray):
         # Explicit fill_value: fill the array and get the list
         if fill_value is not None:
             return self.filled(fill_value).tolist()
-        # Structured array .............
+        # Structured array.
         names = self.dtype.names
         if names:
             result = self._data.astype([(_, object) for _ in names])
             for n in names:
                 result[n][_mask[n]] = None
             return result.tolist()
-        # Standard arrays ...............
+        # Standard arrays.
         if _mask is nomask:
             return [None]
-        # Set temps to save time when dealing w/ marrays...
+        # Set temps to save time when dealing w/ marrays.
         inishape = self.shape
         result = np.array(self._data.ravel(), dtype=object)
         result[_mask.ravel()] = None
         result.shape = inishape
         return result.tolist()
-#        if fill_value is not None:
-#            return self.filled(fill_value).tolist()
-#        result = self.filled().tolist()
-#        # Set temps to save time when dealing w/ mrecarrays...
-#        _mask = self._mask
-#        if _mask is nomask:
-#            return result
-#        nbdims = self.ndim
-#        dtypesize = len(self.dtype)
-#        if nbdims == 0:
-#            return tuple([None] * dtypesize)
-#        elif nbdims == 1:
-#            maskedidx = _mask.nonzero()[0].tolist()
-#            if dtypesize:
-#                nodata = tuple([None] * dtypesize)
-#            else:
-#                nodata = None
-#            [operator.setitem(result, i, nodata) for i in maskedidx]
-#        else:
-#            for idx in zip(*[i.tolist() for i in _mask.nonzero()]):
-#                tmp = result
-#                for i in idx[:-1]:
-#                    tmp = tmp[i]
-#                tmp[idx[-1]] = None
-#        return result
-    #........................
+
     def tostring(self, fill_value=None, order='C'):
         """
         This function is a compatibility alias for tobytes. Despite its name it
@@ -5542,7 +5631,7 @@ class MaskedArray(ndarray):
         """
 
         return self.tobytes(fill_value, order='C')
-    #........................
+
     def tobytes(self, fill_value=None, order='C'):
         """
         Return the array data as a string containing the raw bytes in the array.
@@ -5582,7 +5671,7 @@ class MaskedArray(ndarray):
 
         """
         return self.filled(fill_value).tobytes(order=order)
-    #........................
+
     def tofile(self, fid, sep="", format="%s"):
         """
         Save a masked array to a file in binary format.
@@ -5636,7 +5725,7 @@ class MaskedArray(ndarray):
          [(7, False) (8, True) (9, False)]]
 
         """
-        # Get the basic dtype ....
+        # Get the basic dtype.
         ddtype = self.dtype
         # Make sure we have a mask
         _mask = self._mask
@@ -5644,14 +5733,14 @@ class MaskedArray(ndarray):
             _mask = make_mask_none(self.shape, ddtype)
         # And get its dtype
         mdtype = self._mask.dtype
-        #
+
         record = np.ndarray(shape=self.shape,
                             dtype=[('_data', ddtype), ('_mask', mdtype)])
         record['_data'] = self._data
         record['_mask'] = self._mask
         return record
     torecords = toflex
-    #--------------------------------------------
+
     # Pickling
     def __getstate__(self):
         """Return the internal state of the masked array, for pickling
@@ -5664,13 +5753,13 @@ class MaskedArray(ndarray):
                  self.dtype,
                  self.flags.fnc,
                  self._data.tobytes(cf),
-                 #self._data.tolist(),
+                 # self._data.tolist(),
                  getmaskarray(self).tobytes(cf),
-                 #getmaskarray(self).tolist(),
+                 # getmaskarray(self).tolist(),
                  self._fill_value,
                  )
         return state
-    #
+
     def __setstate__(self, state):
         """Restore the internal state of the masked array, for
         pickling purposes.  ``state`` is typically the output of the
@@ -5687,7 +5776,7 @@ class MaskedArray(ndarray):
         super(MaskedArray, self).__setstate__((shp, typ, isf, raw))
         self._mask.__setstate__((shp, make_mask_descr(typ), isf, msk))
         self.fill_value = flv
-    #
+
     def __reduce__(self):
         """Return a 3-tuple for pickling a MaskedArray.
 
@@ -5695,7 +5784,7 @@ class MaskedArray(ndarray):
         return (_mareconstruct,
                 (self.__class__, self._baseclass, (0,), 'b',),
                 self.__getstate__())
-    #
+
     def __deepcopy__(self, memo=None):
         from copy import deepcopy
         copied = MaskedArray.__new__(type(self), self, copy=True)
@@ -5717,15 +5806,11 @@ def _mareconstruct(subtype, baseclass, baseshape, basetype,):
     return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
 
 
-
-
-
-
 class mvoid(MaskedArray):
     """
     Fake a 'void' object to use for masked array with structured dtypes.
     """
-    #
+
     def __new__(self, data, mask=nomask, dtype=None, fill_value=None,
                 hardmask=False, copy=False, subok=True):
         _data = np.array(data, copy=copy, subok=subok, dtype=dtype)
@@ -5749,10 +5834,14 @@ class mvoid(MaskedArray):
     def _get_data(self):
         # Make sure that the _data part is a np.void
         return self.view(ndarray)[()]
+
     _data = property(fget=_get_data)
 
     def __getitem__(self, indx):
-        "Get the index..."
+        """
+        Get the index.
+
+        """
         m = self._mask
         if m is not nomask and m[indx]:
             return masked
@@ -5857,10 +5946,11 @@ class mvoid(MaskedArray):
         return tuple(result)
 
 
+##############################################################################
+#                                Shortcuts                                   #
+##############################################################################
+
 
-#####--------------------------------------------------------------------------
-#---- --- Shortcuts ---
-#####---------------------------------------------------------------------------
 def isMaskedArray(x):
     """
     Test whether input is an instance of MaskedArray.
@@ -5911,33 +6001,34 @@ def isMaskedArray(x):
 
     """
     return isinstance(x, MaskedArray)
+
+
 isarray = isMaskedArray
-isMA = isMaskedArray  #backward compatibility
+isMA = isMaskedArray  # backward compatibility
 
-# We define the masked singleton as a float for higher precedence...
-# Note that it can be tricky sometimes w/ type comparison
 
 class MaskedConstant(MaskedArray):
-    #
+    # We define the masked singleton as a float for higher precedence.
+    # Note that it can be tricky sometimes w/ type comparison
     _data = data = np.array(0.)
     _mask = mask = np.array(True)
     _baseclass = ndarray
-    #
+
     def __new__(self):
         return self._data.view(self)
-    #
+
     def __array_finalize__(self, obj):
         return
-    #
+
     def __array_wrap__(self, obj):
         return self
-    #
+
     def __str__(self):
         return str(masked_print_option._display)
-    #
+
     def __repr__(self):
         return 'masked'
-    #
+
     def flatten(self):
         return masked_array([self._data], dtype=float, mask=[True])
 
@@ -5948,29 +6039,27 @@ class MaskedConstant(MaskedArray):
 
 
 masked = masked_singleton = MaskedConstant()
-
-
-
 masked_array = MaskedArray
 
+
 def array(data, dtype=None, copy=False, order=False,
           mask=nomask, fill_value=None,
           keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0,
           ):
-    """array(data, dtype=None, copy=False, order=False, mask=nomask,
-             fill_value=None, keep_mask=True, hard_mask=False, shrink=True,
-             subok=True, ndmin=0)
+    """
+    Shortcut to MaskedArray.
 
-    Acts as shortcut to MaskedArray, with options in a different order
-    for convenience.  And backwards compatibility...
+    The options are in a different order for convenience and backwards
+    compatibility.
 
     """
-    #!!!: we should try to put 'order' somwehere
+    # we should try to put 'order' somewhere
     return MaskedArray(data, mask=mask, dtype=dtype, copy=copy, subok=subok,
                        keep_mask=keep_mask, hard_mask=hard_mask,
                        fill_value=fill_value, ndmin=ndmin, shrink=shrink)
 array.__doc__ = masked_array.__doc__
 
+
 def is_masked(x):
     """
     Determine whether input has masked values.
@@ -6024,9 +6113,11 @@ def is_masked(x):
     return False
 
 
-#####---------------------------------------------------------------------------
-#---- --- Extrema functions ---
-#####---------------------------------------------------------------------------
+##############################################################################
+#                             Extrema functions                              #
+##############################################################################
+
+
 class _extrema_operation(object):
     """
     Generic class for maximum/minimum functions.
@@ -6036,18 +6127,19 @@ class _extrema_operation(object):
       `_minimum_operation`.
 
     """
+
     def __call__(self, a, b=None):
         "Executes the call behavior."
         if b is None:
             return self.reduce(a)
         return where(self.compare(a, b), a, b)
-    #.........
+
     def reduce(self, target, axis=None):
         "Reduce target along the given axis."
         target = narray(target, copy=False, subok=True)
         m = getmask(target)
         if axis is not None:
-            kargs = { 'axis' : axis }
+            kargs = {'axis': axis}
         else:
             kargs = {}
             target = target.ravel()
@@ -6056,7 +6148,8 @@ class _extrema_operation(object):
         if m is nomask:
             t = self.ufunc.reduce(target, **kargs)
         else:
-            target = target.filled(self.fill_value_func(target)).view(type(target))
+            target = target.filled(
+                self.fill_value_func(target)).view(type(target))
             t = self.ufunc.reduce(target, **kargs)
             m = umath.logical_and.reduce(m, **kargs)
             if hasattr(t, '_mask'):
@@ -6064,8 +6157,8 @@ class _extrema_operation(object):
             elif m:
                 t = masked
         return t
-    #.........
-    def outer (self, a, b):
+
+    def outer(self, a, b):
         "Return the function applied to the outer product of a and b."
         ma = getmask(a)
         mb = getmask(b)
@@ -6081,10 +6174,12 @@ class _extrema_operation(object):
         result._mask = m
         return result
 
-#............................
+
 class _minimum_operation(_extrema_operation):
+
     "Object to calculate minima"
-    def __init__ (self):
+
+    def __init__(self):
         """minimum(a, b) or minimum(a)
 In one argument case, returns the scalar minimum.
         """
@@ -6093,10 +6188,12 @@ In one argument case, returns the scalar minimum.
         self.compare = less
         self.fill_value_func = minimum_fill_value
 
-#............................
+
 class _maximum_operation(_extrema_operation):
+
     "Object to calculate maxima"
-    def __init__ (self):
+
+    def __init__(self):
         """maximum(a, b) or maximum(a)
            In one argument case returns the scalar maximum.
         """
@@ -6105,39 +6202,46 @@ class _maximum_operation(_extrema_operation):
         self.compare = greater
         self.fill_value_func = maximum_fill_value
 
-#..........................................................
+
 def min(obj, axis=None, out=None, fill_value=None):
     try:
         return obj.min(axis=axis, fill_value=fill_value, out=out)
     except (AttributeError, TypeError):
-        # If obj doesn't have a min method,
-        # ...or if the method doesn't accept a fill_value argument
+        # If obj doesn't have a min method or if the method doesn't accept
+        # a fill_value argument
         return asanyarray(obj).min(axis=axis, fill_value=fill_value, out=out)
 min.__doc__ = MaskedArray.min.__doc__
 
+
 def max(obj, axis=None, out=None, fill_value=None):
     try:
         return obj.max(axis=axis, fill_value=fill_value, out=out)
     except (AttributeError, TypeError):
-        # If obj doesn't have a max method,
-        # ...or if the method doesn't accept a fill_value argument
+        # If obj doesn't have a max method, or if the method doesn't accept
+        # a fill_value argument
         return asanyarray(obj).max(axis=axis, fill_value=fill_value, out=out)
 max.__doc__ = MaskedArray.max.__doc__
 
+
 def ptp(obj, axis=None, out=None, fill_value=None):
-    """a.ptp(axis=None) =  a.max(axis)-a.min(axis)"""
+    """
+    a.ptp(axis=None) =  a.max(axis) - a.min(axis)
+
+    """
     try:
         return obj.ptp(axis, out=out, fill_value=fill_value)
     except (AttributeError, TypeError):
-        # If obj doesn't have a ptp method,
-        # ...or if the method doesn't accept a fill_value argument
+        # If obj doesn't have a ptp method or if the method doesn't accept
+        # a fill_value argument
         return asanyarray(obj).ptp(axis=axis, fill_value=fill_value, out=out)
 ptp.__doc__ = MaskedArray.ptp.__doc__
 
 
-#####---------------------------------------------------------------------------
-#---- --- Definition of functions from the corresponding methods ---
-#####---------------------------------------------------------------------------
+##############################################################################
+#           Definition of functions from the corresponding methods           #
+##############################################################################
+
+
 class _frommethod:
     """
     Define functions from existing MaskedArray methods.
@@ -6148,20 +6252,22 @@ class _frommethod:
         Name of the method to transform.
 
     """
+
     def __init__(self, methodname, reversed=False):
         self.__name__ = methodname
         self.__doc__ = self.getdoc()
         self.reversed = reversed
-    #
+
     def getdoc(self):
         "Return the doc of the function (from the doc of the method)."
         meth = getattr(MaskedArray, self.__name__, None) or\
-               getattr(np, self.__name__, None)
+            getattr(np, self.__name__, None)
         signature = self.__name__ + get_object_signature(meth)
         if meth is not None:
-            doc = """    %s\n%s""" % (signature, getattr(meth, '__doc__', None))
+            doc = """    %s\n%s""" % (
+                signature, getattr(meth, '__doc__', None))
             return doc
-    #
+
     def __call__(self, a, *args, **params):
         if self.reversed:
             args = list(args)
@@ -6181,6 +6287,7 @@ class _frommethod:
         method = getattr(np, method_name)
         return method(a, *args, **params)
 
+
 all = _frommethod('all')
 anomalies = anom = _frommethod('anom')
 any = _frommethod('any')
@@ -6208,6 +6315,7 @@ swapaxes = _frommethod('swapaxes')
 trace = _frommethod('trace')
 var = _frommethod('var')
 
+
 def take(a, indices, axis=None, out=None, mode='raise'):
     """
     """
@@ -6215,7 +6323,6 @@ def take(a, indices, axis=None, out=None, mode='raise'):
     return a.take(indices, axis=axis, out=out, mode=mode)
 
 
-#..............................................................................
 def power(a, b, third=None):
     """
     Returns element-wise base array raised to power from second array.
@@ -6267,20 +6374,7 @@ def power(a, b, third=None):
         result._data[invalid] = result.fill_value
     return result
 
-#    if fb.dtype.char in typecodes["Integer"]:
-#        return masked_array(umath.power(fa, fb), m)
-#    m = mask_or(m, (fa < 0) & (fb != fb.astype(int)))
-#    if m is nomask:
-#        return masked_array(umath.power(fa, fb))
-#    else:
-#        fa = fa.copy()
-#        if m.all():
-#            fa.flat = 1
-#        else:
-#            np.copyto(fa, 1, where=m)
-#        return masked_array(umath.power(fa, fb), m)
-
-#..............................................................................
+
 def argsort(a, axis=None, kind='quicksort', order=None, fill_value=None):
     "Function version of the eponymous method."
     if fill_value is None:
@@ -6291,6 +6385,7 @@ def argsort(a, axis=None, kind='quicksort', order=None, fill_value=None):
     return d.argsort(axis, kind=kind, order=order)
 argsort.__doc__ = MaskedArray.argsort.__doc__
 
+
 def argmin(a, axis=None, fill_value=None):
     "Function version of the eponymous method."
     if fill_value is None:
@@ -6299,6 +6394,7 @@ def argmin(a, axis=None, fill_value=None):
     return d.argmin(axis=axis)
 argmin.__doc__ = MaskedArray.argmin.__doc__
 
+
 def argmax(a, axis=None, fill_value=None):
     "Function version of the eponymous method."
     if fill_value is None:
@@ -6311,7 +6407,8 @@ def argmax(a, axis=None, fill_value=None):
     return d.argmax(axis=axis)
 argmax.__doc__ = MaskedArray.argmax.__doc__
 
-def sort(a, axis= -1, kind='quicksort', order=None, endwith=True, fill_value=None):
+
+def sort(a, axis=-1, kind='quicksort', order=None, endwith=True, fill_value=None):
     "Function version of the eponymous method."
     a = narray(a, copy=True, subok=True)
     if axis is None:
@@ -6404,7 +6501,7 @@ def concatenate(arrays, axis=0):
     d = np.concatenate([getdata(a) for a in arrays], axis)
     rcls = get_masked_subclass(*arrays)
     data = d.view(rcls)
-    # Check whether one of the arrays has a non-empty mask...
+    # Check whether one of the arrays has a non-empty mask.
     for x in arrays:
         if getmask(x) is not nomask:
             break
@@ -6412,16 +6509,15 @@ def concatenate(arrays, axis=0):
         return data
     # OK, so we have to concatenate the masks
     dm = np.concatenate([getmaskarray(a) for a in arrays], axis)
-    # If we decide to keep a '_shrinkmask' option, we want to check that ...
-    # ... all of them are True, and then check for dm.any()
-#    shrink = numpy.logical_or.reduce([getattr(a,'_shrinkmask',True) for a in arrays])
-#    if shrink and not dm.any():
+    # If we decide to keep a '_shrinkmask' option, we want to check that
+    # all of them are True, and then check for dm.any()
     if not dm.dtype.fields and not dm.any():
         data._mask = nomask
     else:
         data._mask = dm.reshape(d.shape)
     return data
 
+
 def count(a, axis=None):
     if isinstance(a, MaskedArray):
         return a.count(axis)
@@ -6496,8 +6592,8 @@ def expand_dims(x, axis):
             result._mask.shape = new_shape
     return result
 
-#......................................
-def left_shift (a, n):
+
+def left_shift(a, n):
     """
     Shift the bits of an integer to the left.
 
@@ -6517,7 +6613,8 @@ def left_shift (a, n):
         d = umath.left_shift(filled(a, 0), n)
         return masked_array(d, mask=m)
 
-def right_shift (a, n):
+
+def right_shift(a, n):
     """
     Shift the bits of an integer to the right.
 
@@ -6537,7 +6634,7 @@ def right_shift (a, n):
         d = umath.right_shift(filled(a, 0), n)
         return masked_array(d, mask=m)
 
-#......................................
+
 def put(a, indices, values, mode='raise'):
     """
     Set storage-indexed locations to corresponding values.
@@ -6556,7 +6653,8 @@ def put(a, indices, values, mode='raise'):
     except AttributeError:
         return narray(a, copy=False).put(indices, values, mode=mode)
 
-def putmask(a, mask, values): #, mode='raise'):
+
+def putmask(a, mask, values):  # , mode='raise'):
     """
     Changes elements of an array based on conditional and input values.
 
@@ -6594,6 +6692,7 @@ def putmask(a, mask, values): #, mode='raise'):
     np.copyto(a._data, valdata, where=mask)
     return
 
+
 def transpose(a, axes=None):
     """
     Permute the dimensions of an array.
@@ -6627,12 +6726,13 @@ def transpose(a, axes=None):
            fill_value = 999999)
 
     """
-    #We can't use 'frommethod', as 'transpose' doesn't take keywords
+    # We can't use 'frommethod', as 'transpose' doesn't take keywords
     try:
         return a.transpose(axes)
     except AttributeError:
         return narray(a, copy=False).transpose(axes).view(MaskedArray)
 
+
 def reshape(a, new_shape, order='C'):
     """
     Returns an array containing the same data with a new shape.
@@ -6644,13 +6744,14 @@ def reshape(a, new_shape, order='C'):
     MaskedArray.reshape : equivalent function
 
     """
-    #We can't use 'frommethod', it whine about some parameters. Dmmit.
+    # We can't use 'frommethod', it whine about some parameters. Dmmit.
     try:
         return a.reshape(new_shape, order=order)
     except AttributeError:
         _tmp = narray(a, copy=False).reshape(new_shape, order=order)
         return _tmp.view(MaskedArray)
 
+
 def resize(x, new_shape):
     """
     Return a new masked array with the specified size and shape.
@@ -6715,26 +6816,50 @@ def resize(x, new_shape):
     return result
 
 
-#................................................
-def rank(obj):
-    "maskedarray version of the numpy function."
-    return np.rank(getdata(obj))
+def rank(obj): 
+    """
+    maskedarray version of the numpy function.
+
+    .. note::
+        Deprecated since 1.10.0
+
+    """
+    # 2015-04-12, 1.10.0
+    warnings.warn(
+        "`rank` is deprecated; use the `ndim` function instead. ",
+        np.VisibleDeprecationWarning)
+    return np.ndim(getdata(obj))
+
 rank.__doc__ = np.rank.__doc__
-#
+
+
+def ndim(obj): 
+    """
+    maskedarray version of the numpy function.
+
+    """
+    return np.ndim(getdata(obj))
+
+ndim.__doc__ = np.ndim.__doc__
+
+
 def shape(obj):
     "maskedarray version of the numpy function."
     return np.shape(getdata(obj))
 shape.__doc__ = np.shape.__doc__
-#
+
+
 def size(obj, axis=None):
     "maskedarray version of the numpy function."
     return np.size(getdata(obj), axis)
 size.__doc__ = np.size.__doc__
-#................................................
 
-#####--------------------------------------------------------------------------
-#---- --- Extra functions ---
-#####--------------------------------------------------------------------------
+
+##############################################################################
+#                            Extra functions                                 #
+##############################################################################
+
+
 def where(condition, x=_NoValue, y=_NoValue):
     """
     Return a masked array with elements from x or y, depending on condition.
@@ -6822,7 +6947,7 @@ def where(condition, x=_NoValue, y=_NoValue):
     return d
 
 
-def choose (indices, choices, out=None, mode='raise'):
+def choose(indices, choices, out=None, mode='raise'):
     """
     Use an index array to construct a new array from a set of choices.
 
@@ -6867,26 +6992,27 @@ def choose (indices, choices, out=None, mode='raise'):
           fill_value=999999)
 
     """
-    def fmask (x):
+    def fmask(x):
         "Returns the filled array, or True if masked."
         if x is masked:
             return True
         return filled(x)
-    def nmask (x):
+
+    def nmask(x):
         "Returns the mask, True if ``masked``, False if ``nomask``."
         if x is masked:
             return True
         return getmask(x)
-    # Get the indices......
+    # Get the indices.
     c = filled(indices, 0)
-    # Get the masks........
+    # Get the masks.
     masks = [nmask(x) for x in choices]
     data = [fmask(x) for x in choices]
     # Construct the mask
     outputmask = np.choose(c, masks, mode=mode)
     outputmask = make_mask(mask_or(outputmask, getmask(indices)),
                            copy=0, shrink=True)
-    # Get the choices......
+    # Get the choices.
     d = np.choose(c, data, mode=mode, out=out).view(MaskedArray)
     if out is not None:
         if isinstance(out, MaskedArray):
@@ -6929,6 +7055,7 @@ def round_(a, decimals=0, out=None):
         return out
 round = round_
 
+
 def inner(a, b):
     """
     Returns the inner product of a and b for arrays of floating point types.
@@ -6952,6 +7079,7 @@ inner.__doc__ = doc_note(np.inner.__doc__,
                          "Masked values are replaced by 0.")
 innerproduct = inner
 
+
 def outer(a, b):
     "maskedarray version of the numpy function."
     fa = filled(a, 0).ravel()
@@ -6969,7 +7097,8 @@ outer.__doc__ = doc_note(np.outer.__doc__,
                          "Masked values are replaced by 0.")
 outerproduct = outer
 
-def allequal (a, b, fill_value=True):
+
+def allequal(a, b, fill_value=True):
     """
     Return True if all entries of a and b are equal, using
     fill_value as a truth value where either or both are masked.
@@ -7026,7 +7155,8 @@ def allequal (a, b, fill_value=True):
     else:
         return False
 
-def allclose (a, b, masked_equal=True, rtol=1e-5, atol=1e-8):
+
+def allclose(a, b, masked_equal=True, rtol=1e-5, atol=1e-8):
     """
     Returns True if two arrays are element-wise equal within a tolerance.
 
@@ -7130,7 +7260,7 @@ def allclose (a, b, masked_equal=True, rtol=1e-5, atol=1e-8):
 
     return np.all(d)
 
-#..............................................................................
+
 def asarray(a, dtype=None, order=None):
     """
     Convert the input to a masked array of the given data-type.
@@ -7178,6 +7308,7 @@ def asarray(a, dtype=None, order=None):
     """
     return masked_array(a, dtype=dtype, copy=False, keep_mask=True, subok=False)
 
+
 def asanyarray(a, dtype=None):
     """
     Convert the input to a masked array, conserving subclasses.
@@ -7224,9 +7355,9 @@ def asanyarray(a, dtype=None):
     return masked_array(a, dtype=dtype, copy=False, keep_mask=True, subok=True)
 
 
-#####--------------------------------------------------------------------------
-#---- --- Pickling ---
-#####--------------------------------------------------------------------------
+##############################################################################
+#                               Pickling                                     #
+##############################################################################
 def dump(a, F):
     """
     Pickle a masked array to a file.
@@ -7245,6 +7376,7 @@ def dump(a, F):
         F = open(F, 'w')
     return pickle.dump(a, F)
 
+
 def dumps(a):
     """
     Return a string corresponding to the pickling of a masked array.
@@ -7260,6 +7392,7 @@ def dumps(a):
     """
     return pickle.dumps(a)
 
+
 def load(F):
     """
     Wrapper around ``cPickle.load`` which accepts either a file-like object
@@ -7284,6 +7417,7 @@ def load(F):
         F = open(F, 'r')
     return pickle.load(F)
 
+
 def loads(strg):
     """
     Load a pickle from the current string.
@@ -7302,9 +7436,10 @@ def loads(strg):
     """
     return pickle.loads(strg)
 
-################################################################################
-def fromfile(file, dtype=float, count= -1, sep=''):
-    raise NotImplementedError("fromfile() not yet implemented for a MaskedArray.")
+
+def fromfile(file, dtype=float, count=-1, sep=''):
+    raise NotImplementedError(
+        "fromfile() not yet implemented for a MaskedArray.")
 
 
 def fromflex(fxarray):
@@ -7372,8 +7507,8 @@ def fromflex(fxarray):
     return masked_array(fxarray['_data'], mask=fxarray['_mask'])
 
 
-
 class _convert2ma:
+
     """
     Convert functions from numpy to numpy.ma.
 
@@ -7384,12 +7519,12 @@ class _convert2ma:
 
     """
     __doc__ = None
-    #
+
     def __init__(self, funcname, params=None):
         self._func = getattr(np, funcname)
         self.__doc__ = self.getdoc()
         self._extras = params or {}
-    #
+
     def getdoc(self):
         "Return the doc of the function (from the doc of the method)."
         doc = getattr(self._func, '__doc__', None)
@@ -7400,7 +7535,7 @@ class _convert2ma:
                 sig = "%s%s\n" % (self._func.__name__, sig)
             doc = sig + doc
         return doc
-    #
+
     def __call__(self, a, *args, **params):
         # Find the common parameters to the call and the definition
         _extras = self._extras
@@ -7423,7 +7558,8 @@ empty = _convert2ma('empty', params=dict(fill_value=None, hardmask=False))
 empty_like = _convert2ma('empty_like')
 frombuffer = _convert2ma('frombuffer')
 fromfunction = _convert2ma('fromfunction')
-identity = _convert2ma('identity', params=dict(fill_value=None, hardmask=False))
+identity = _convert2ma(
+    'identity', params=dict(fill_value=None, hardmask=False))
 indices = np.indices
 ones = _convert2ma('ones', params=dict(fill_value=None, hardmask=False))
 ones_like = np.ones_like
@@ -7431,7 +7567,7 @@ squeeze = np.squeeze
 zeros = _convert2ma('zeros', params=dict(fill_value=None, hardmask=False))
 zeros_like = np.zeros_like
 
-###############################################################################
+
 def append(a, b, axis=None):
     """Append values to the end of an array.
 
diff --git a/numpy/ma/extras.py b/numpy/ma/extras.py
index bd593e65f..a47c58684 100644
--- a/numpy/ma/extras.py
+++ b/numpy/ma/extras.py
@@ -10,39 +10,27 @@ A collection of utilities for `numpy.ma`.
 """
 from __future__ import division, absolute_import, print_function
 
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__ = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-__all__ = ['apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d',
-           'atleast_3d', 'average',
-           'clump_masked', 'clump_unmasked', 'column_stack', 'compress_cols',
-           'compress_nd', 'compress_rowcols', 'compress_rows', 'count_masked',
-           'corrcoef', 'cov',
-           'diagflat', 'dot', 'dstack',
-           'ediff1d',
-           'flatnotmasked_contiguous', 'flatnotmasked_edges',
-           'hsplit', 'hstack',
-           'in1d', 'intersect1d',
-           'mask_cols', 'mask_rowcols', 'mask_rows', 'masked_all',
-           'masked_all_like', 'median', 'mr_',
-           'notmasked_contiguous', 'notmasked_edges',
-           'polyfit',
-           'row_stack',
-           'setdiff1d', 'setxor1d',
-           'unique', 'union1d',
-           'vander', 'vstack',
-           ]
+__all__ = [
+    'apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d',
+    'atleast_3d', 'average', 'clump_masked', 'clump_unmasked',
+    'column_stack', 'compress_cols', 'compress_nd', 'compress_rowcols',
+    'compress_rows', 'count_masked', 'corrcoef', 'cov', 'diagflat', 'dot',
+    'dstack', 'ediff1d', 'flatnotmasked_contiguous', 'flatnotmasked_edges',
+    'hsplit', 'hstack', 'in1d', 'intersect1d', 'mask_cols', 'mask_rowcols',
+    'mask_rows', 'masked_all', 'masked_all_like', 'median', 'mr_',
+    'notmasked_contiguous', 'notmasked_edges', 'polyfit', 'row_stack',
+    'setdiff1d', 'setxor1d', 'unique', 'union1d', 'vander', 'vstack',
+    ]
 
 import itertools
 import warnings
 
 from . import core as ma
-from .core import MaskedArray, MAError, add, array, asarray, concatenate, count, \
-    filled, getmask, getmaskarray, make_mask_descr, masked, masked_array, \
-    mask_or, nomask, ones, sort, zeros, getdata
-#from core import *
+from .core import (
+    MaskedArray, MAError, add, array, asarray, concatenate, filled,
+    getmask, getmaskarray, make_mask_descr, masked, masked_array, mask_or,
+    nomask, ones, sort, zeros, getdata
+    )
 
 import numpy as np
 from numpy import ndarray, array as nxarray
@@ -50,9 +38,11 @@ import numpy.core.umath as umath
 from numpy.lib.index_tricks import AxisConcatenator
 
 
-#...............................................................................
 def issequence(seq):
-    """Is seq a sequence (ndarray, list or tuple)?"""
+    """
+    Is seq a sequence (ndarray, list or tuple)?
+
+    """
     if isinstance(seq, (ndarray, tuple, list)):
         return True
     return False
@@ -268,7 +258,6 @@ class _fromnxfunction:
             return '\n'.join((sig, doc, locdoc))
         return
 
-
     def __call__(self, *args, **params):
         func = getattr(np, self.__name__)
         if len(args) == 1:
@@ -350,9 +339,9 @@ def apply_along_axis(func1d, axis, arr, *args, **kwargs):
             len(res)
         except TypeError:
             asscalar = True
-    # Note: we shouldn't set the dtype of the output from the first result...
-    #...so we force the type to object, and build a list of dtypes
-    #...we'll just take the largest, to avoid some downcasting
+    # Note: we shouldn't set the dtype of the output from the first result
+    # so we force the type to object, and build a list of dtypes.  We'll
+    # just take the largest, to avoid some downcasting
     dtypes = []
     if asscalar:
         dtypes.append(np.asarray(res).dtype)
@@ -420,7 +409,8 @@ def apply_over_axes(func, a, axes):
     if array(axes).ndim == 0:
         axes = (axes,)
     for axis in axes:
-        if axis < 0: axis = N + axis
+        if axis < 0:
+            axis = N + axis
         args = (val, axis)
         res = func(*args)
         if res.ndim == val.ndim:
@@ -557,10 +547,9 @@ def average(a, axis=None, weights=None, returned=False):
                     d = add.reduce(w, axis)
                     del w
                 elif wsh == (ash[axis],):
-                    ni = ash[axis]
                     r = [None] * len(ash)
                     r[axis] = slice(None, None, 1)
-                    w = eval ("w[" + repr(tuple(r)) + "] * ones(ash, float)")
+                    w = eval("w[" + repr(tuple(r)) + "] * ones(ash, float)")
                     n = add.reduce(a * w, axis)
                     d = add.reduce(w, axis, dtype=float)
                     del w, r
@@ -580,11 +569,10 @@ def average(a, axis=None, weights=None, returned=False):
                     n = add.reduce(a * w, axis)
                     d = add.reduce(w, axis, dtype=float)
                 elif wsh == (ash[axis],):
-                    ni = ash[axis]
                     r = [None] * len(ash)
                     r[axis] = slice(None, None, 1)
-                    w = eval ("w[" + repr(tuple(r)) + \
-                              "] * masked_array(ones(ash, float), mask)")
+                    w = eval("w[" + repr(tuple(r)) +
+                             "] * masked_array(ones(ash, float), mask)")
                     n = add.reduce(a * w, axis)
                     d = add.reduce(w, axis, dtype=float)
                 else:
@@ -715,7 +703,6 @@ def median(a, axis=None, out=None, overwrite_input=False):
     return s
 
 
-#..............................................................................
 def compress_nd(x, axis=None):
     """Supress slices from multiple dimensions which contain masked values.
 
@@ -1284,11 +1271,9 @@ def setdiff1d(ar1, ar2, assume_unique=False):
     return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]
 
 
-#####--------------------------------------------------------------------------
-#---- --- Covariance ---
-#####--------------------------------------------------------------------------
-
-
+###############################################################################
+#                                Covariance                                   #
+###############################################################################
 
 
 def _covhelper(x, y=None, rowvar=True, allow_masked=True):
@@ -1301,7 +1286,7 @@ def _covhelper(x, y=None, rowvar=True, allow_masked=True):
     xmask = ma.getmaskarray(x)
     # Quick exit if we can't process masked data
     if not allow_masked and xmask.any():
-        raise ValueError("Cannot process masked data...")
+        raise ValueError("Cannot process masked data.")
     #
     if x.shape[0] == 1:
         rowvar = True
@@ -1319,7 +1304,7 @@ def _covhelper(x, y=None, rowvar=True, allow_masked=True):
         y = array(y, copy=False, ndmin=2, dtype=float)
         ymask = ma.getmaskarray(y)
         if not allow_masked and ymask.any():
-            raise ValueError("Cannot process masked data...")
+            raise ValueError("Cannot process masked data.")
         if xmask.any() or ymask.any():
             if y.shape == x.shape:
                 # Define some common mask
@@ -1912,26 +1897,29 @@ def clump_masked(a):
     return slices
 
 
+###############################################################################
+#                              Polynomial fit                                 #
+###############################################################################
 
-#####--------------------------------------------------------------------------
-#---- Polynomial fit ---
-#####--------------------------------------------------------------------------
 
 def vander(x, n=None):
     """
     Masked values in the input array result in rows of zeros.
+
     """
     _vander = np.vander(x, n)
     m = getmask(x)
     if m is not nomask:
         _vander[m] = 0
     return _vander
+
 vander.__doc__ = ma.doc_note(np.vander.__doc__, vander.__doc__)
 
 
 def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
     """
     Any masked values in x is propagated in y, and vice-versa.
+
     """
     x = asarray(x)
     y = asarray(y)
@@ -1950,7 +1938,7 @@ def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
         w = asarray(w)
         if w.ndim != 1:
             raise TypeError("expected a 1-d array for weights")
-        if w.shape[0] != y.shape[0] :
+        if w.shape[0] != y.shape[0]:
             raise TypeError("expected w and y to have the same length")
         m = mask_or(m, getmask(w))
 
@@ -1963,5 +1951,3 @@ def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
         return np.polyfit(x, y, deg, rcond, full, w, cov)
 
 polyfit.__doc__ = ma.doc_note(np.polyfit.__doc__, polyfit.__doc__)
-
-################################################################################
diff --git a/numpy/ma/mrecords.py b/numpy/ma/mrecords.py
index 644383925..382bcc972 100644
--- a/numpy/ma/mrecords.py
+++ b/numpy/ma/mrecords.py
@@ -5,19 +5,15 @@ where fields can be accessed as attributes.
 Note that :class:`numpy.ma.MaskedArray` already supports structured datatypes
 and the masking of individual fields.
 
-:author: Pierre Gerard-Marchant
+.. moduleauthor:: Pierre Gerard-Marchant
 
 """
 from __future__ import division, absolute_import, print_function
 
-#!!!: * We should make sure that no field is called '_mask','mask','_fieldmask',
-#!!!:   or whatever restricted keywords.
-#!!!:   An idea would be to no bother in the first place, and then rename the
-#!!!:   invalid fields with a trailing underscore...
-#!!!:   Maybe we could just overload the parser function ?
-
-
-__author__ = "Pierre GF Gerard-Marchant"
+#  We should make sure that no field is called '_mask','mask','_fieldmask',
+#  or whatever restricted keywords.  An idea would be to no bother in the
+#  first place, and then rename the invalid fields with a trailing
+#  underscore. Maybe we could just overload the parser function ?
 
 import sys
 import warnings
@@ -36,20 +32,27 @@ _byteorderconv = np.core.records._byteorderconv
 _typestr = ntypes._typestr
 
 import numpy.ma as ma
-from numpy.ma import MAError, MaskedArray, masked, nomask, masked_array, \
-                     getdata, getmaskarray, filled
+from numpy.ma import (
+        MAError, MaskedArray, masked, nomask, masked_array, getdata,
+        getmaskarray, filled
+        )
 
 _check_fill_value = ma.core._check_fill_value
 
 
-__all__ = ['MaskedRecords', 'mrecarray',
-           'fromarrays', 'fromrecords', 'fromtextfile', 'addfield',
-           ]
+__all__ = [
+    'MaskedRecords', 'mrecarray', 'fromarrays', 'fromrecords',
+    'fromtextfile', 'addfield',
+    ]
 
 reserved_fields = ['_data', '_mask', '_fieldmask', 'dtype']
 
+
 def _getformats(data):
-    "Returns the formats of each array of arraylist as a comma-separated string."
+    """
+    Returns the formats of arrays in arraylist as a comma-separated string.
+
+    """
     if hasattr(data, 'dtype'):
         return ",".join([desc[1] for desc in data.dtype.descr])
 
@@ -62,10 +65,14 @@ def _getformats(data):
         formats += ','
     return formats[:-1]
 
+
 def _checknames(descr, names=None):
-    """Checks that the field names of the descriptor ``descr`` are not some
-reserved keywords. If this is the case, a default 'f%i' is substituted.
-If the argument `names` is not None, updates the field names to valid names.
+    """
+    Checks that field names ``descr`` are not reserved keywords.
+
+    If this is the case, a default 'f%i' is substituted.  If the argument
+    `names` is not None, updates the field names to valid names.
+
     """
     ndescr = len(descr)
     default_names = ['f%i' % i for i in range(ndescr)]
@@ -103,29 +110,33 @@ def _get_fieldmask(self):
 class MaskedRecords(MaskedArray, object):
     """
 
-*IVariables*:
-    _data : {recarray}
+    Attributes
+    ----------
+    _data : recarray
         Underlying data, as a record array.
-    _mask : {boolean array}
-        Mask of the records. A record is masked when all its fields are masked.
-    _fieldmask : {boolean recarray}
-        Record array of booleans, setting the mask of each individual field of each record.
-    _fill_value : {record}
+    _mask : boolean array
+        Mask of the records. A record is masked when all its fields are
+        masked.
+    _fieldmask : boolean recarray
+        Record array of booleans, setting the mask of each individual field
+        of each record.
+    _fill_value : record
         Filling values for each field.
+
     """
-    #............................................
+
     def __new__(cls, shape, dtype=None, buf=None, offset=0, strides=None,
                 formats=None, names=None, titles=None,
                 byteorder=None, aligned=False,
                 mask=nomask, hard_mask=False, fill_value=None, keep_mask=True,
                 copy=False,
                 **options):
-        #
+
         self = recarray.__new__(cls, shape, dtype=dtype, buf=buf, offset=offset,
                                 strides=strides, formats=formats, names=names,
                                 titles=titles, byteorder=byteorder,
                                 aligned=aligned,)
-        #
+
         mdtype = ma.make_mask_descr(self.dtype)
         if mask is nomask or not np.size(mask):
             if not keep_mask:
@@ -154,9 +165,9 @@ class MaskedRecords(MaskedArray, object):
                                      dtype=mdtype)
                 self._mask = _mask
         return self
-    #......................................................
+
     def __array_finalize__(self, obj):
-        # Make sure we have a _fieldmask by default ..
+        # Make sure we have a _fieldmask by default
         _mask = getattr(obj, '_mask', None)
         if _mask is None:
             objmask = getattr(obj, '_mask', nomask)
@@ -175,19 +186,29 @@ class MaskedRecords(MaskedArray, object):
             _dict['_baseclass'] = recarray
         return
 
-
     def _getdata(self):
-        "Returns the data as a recarray."
+        """
+        Returns the data as a recarray.
+
+        """
         return ndarray.view(self, recarray)
+
     _data = property(fget=_getdata)
 
     def _getfieldmask(self):
-        "Alias to mask"
+        """
+        Alias to mask.
+
+        """
         return self._mask
+
     _fieldmask = property(fget=_getfieldmask)
 
     def __len__(self):
-        "Returns the length"
+        """
+        Returns the length
+
+        """
         # We have more than one record
         if self.ndim:
             return len(self._data)
@@ -197,20 +218,21 @@ class MaskedRecords(MaskedArray, object):
     def __getattribute__(self, attr):
         try:
             return object.__getattribute__(self, attr)
-        except AttributeError: # attr must be a fieldname
+        except AttributeError:
+            # attr must be a fieldname
             pass
         fielddict = ndarray.__getattribute__(self, 'dtype').fields
         try:
             res = fielddict[attr][:2]
         except (TypeError, KeyError):
             raise AttributeError("record array has no attribute %s" % attr)
-        # So far, so good...
+        # So far, so good
         _localdict = ndarray.__getattribute__(self, '__dict__')
         _data = ndarray.view(self, _localdict['_baseclass'])
         obj = _data.getfield(*res)
         if obj.dtype.fields:
-            raise NotImplementedError("MaskedRecords is currently limited to"\
-                                      "simple records...")
+            raise NotImplementedError("MaskedRecords is currently limited to"
+                                      "simple records.")
         # Get some special attributes
         # Reset the object's mask
         hasmasked = False
@@ -238,9 +260,11 @@ class MaskedRecords(MaskedArray, object):
             obj = obj.item()
         return obj
 
-
     def __setattr__(self, attr, val):
-        "Sets the attribute attr to the value val."
+        """
+        Sets the attribute attr to the value val.
+
+        """
         # Should we call __setmask__ first ?
         if attr in ['mask', 'fieldmask']:
             self.__setmask__(val)
@@ -260,14 +284,15 @@ class MaskedRecords(MaskedArray, object):
                 exctype, value = sys.exc_info()[:2]
                 raise exctype(value)
         else:
-            # Get the list of names ......
+            # Get the list of names
             fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
             # Check the attribute
             if attr not in fielddict:
                 return ret
-            if newattr:         # We just added this one
-                try:            #  or this setattr worked on an internal
-                                #  attribute.
+            if newattr:
+                # We just added this one or this setattr worked on an
+                # internal attribute.
+                try:
                     object.__delattr__(self, attr)
                 except:
                     return ret
@@ -276,7 +301,7 @@ class MaskedRecords(MaskedArray, object):
             res = fielddict[attr][:2]
         except (TypeError, KeyError):
             raise AttributeError("record array has no attribute %s" % attr)
-        #
+
         if val is masked:
             _fill_value = _localdict['_fill_value']
             if _fill_value is not None:
@@ -291,19 +316,22 @@ class MaskedRecords(MaskedArray, object):
         _localdict['_mask'].__setitem__(attr, mval)
         return obj
 
-
     def __getitem__(self, indx):
-        """Returns all the fields sharing the same fieldname base.
-The fieldname base is either `_data` or `_mask`."""
+        """
+        Returns all the fields sharing the same fieldname base.
+
+        The fieldname base is either `_data` or `_mask`.
+
+        """
         _localdict = self.__dict__
         _mask = ndarray.__getattribute__(self, '_mask')
         _data = ndarray.view(self, _localdict['_baseclass'])
-        # We want a field ........
+        # We want a field
         if isinstance(indx, basestring):
-            #!!!: Make sure _sharedmask is True to propagate back to _fieldmask
-            #!!!: Don't use _set_mask, there are some copies being made...
-            #!!!: ...that break propagation
-            #!!!: Don't force the mask to nomask, that wrecks easy masking
+            # Make sure _sharedmask is True to propagate back to _fieldmask
+            # Don't use _set_mask, there are some copies being made that
+            # break propagation Don't force the mask to nomask, that wreaks
+            # easy masking
             obj = _data[indx].view(MaskedArray)
             obj._mask = _mask[indx]
             obj._sharedmask = True
@@ -314,21 +342,26 @@ The fieldname base is either `_data` or `_mask`."""
             if not obj.ndim and obj._mask:
                 return masked
             return obj
-        # We want some elements ..
-        # First, the data ........
+        # We want some elements.
+        # First, the data.
         obj = np.array(_data[indx], copy=False).view(mrecarray)
         obj._mask = np.array(_mask[indx], copy=False).view(recarray)
         return obj
-    #....
+
     def __setitem__(self, indx, value):
-        "Sets the given record to value."
+        """
+        Sets the given record to value.
+
+        """
         MaskedArray.__setitem__(self, indx, value)
         if isinstance(indx, basestring):
             self._mask[indx] = ma.getmaskarray(value)
 
-
     def __str__(self):
-        "Calculates the string representation."
+        """
+        Calculates the string representation.
+
+        """
         if self.size > 1:
             mstr = ["(%s)" % ",".join([str(i) for i in s])
                     for s in zip(*[getattr(self, f) for f in self.dtype.names])]
@@ -337,9 +370,12 @@ The fieldname base is either `_data` or `_mask`."""
             mstr = ["%s" % ",".join([str(i) for i in s])
                     for s in zip([getattr(self, f) for f in self.dtype.names])]
             return "(%s)" % ", ".join(mstr)
-    #
+
     def __repr__(self):
-        "Calculates the repr representation."
+        """
+        Calculates the repr representation.
+
+        """
         _names = self.dtype.names
         fmt = "%%%is : %%s" % (max([len(n) for n in _names]) + 4,)
         reprstr = [fmt % (f, getattr(self, f)) for f in self.dtype.names]
@@ -347,16 +383,19 @@ The fieldname base is either `_data` or `_mask`."""
         reprstr.extend([fmt % ('    fill_value', self.fill_value),
                          '              )'])
         return str("\n".join(reprstr))
-#    #......................................................
+
     def view(self, dtype=None, type=None):
-        """Returns a view of the mrecarray."""
-        # OK, basic copy-paste from MaskedArray.view...
+        """
+        Returns a view of the mrecarray.
+
+        """
+        # OK, basic copy-paste from MaskedArray.view.
         if dtype is None:
             if type is None:
                 output = ndarray.view(self)
             else:
                 output = ndarray.view(self, type)
-        # Here again...
+        # Here again.
         elif type is None:
             try:
                 if issubclass(dtype, ndarray):
@@ -368,8 +407,8 @@ The fieldname base is either `_data` or `_mask`."""
             except TypeError:
                 dtype = np.dtype(dtype)
                 # we need to revert to MaskedArray, but keeping the possibility
-                # ...of subclasses (eg, TimeSeriesRecords), so we'll force a type
-                # ...set to the first parent
+                # of subclasses (eg, TimeSeriesRecords), so we'll force a type
+                # set to the first parent
                 if dtype.fields is None:
                     basetype = self.__class__.__bases__[0]
                     output = self.__array__().view(dtype, basetype)
@@ -387,27 +426,35 @@ The fieldname base is either `_data` or `_mask`."""
         return output
 
     def harden_mask(self):
-        "Forces the mask to hard"
+        """
+        Forces the mask to hard.
+
+        """
         self._hardmask = True
+
     def soften_mask(self):
-        "Forces the mask to soft"
+        """
+        Forces the mask to soft
+
+        """
         self._hardmask = False
 
     def copy(self):
-        """Returns a copy of the masked record."""
-        _localdict = self.__dict__
+        """
+        Returns a copy of the masked record.
+
+        """
         copied = self._data.copy().view(type(self))
         copied._mask = self._mask.copy()
         return copied
 
     def tolist(self, fill_value=None):
-        """Copy the data portion of the array to a hierarchical python
-        list and returns that list.
+        """
+        Return the data portion of the array as a list.
 
-        Data items are converted to the nearest compatible Python
-        type.  Masked values are converted to fill_value. If
-        fill_value is None, the corresponding entries in the output
-        list will be ``None``.
+        Data items are converted to the nearest compatible Python type.
+        Masked values are converted to fill_value. If fill_value is None,
+        the corresponding entries in the output list will be ``None``.
 
         """
         if fill_value is not None:
@@ -416,10 +463,11 @@ The fieldname base is either `_data` or `_mask`."""
         mask = narray(self._mask.tolist())
         result[mask] = None
         return result.tolist()
-    #--------------------------------------------
-    # Pickling
+
     def __getstate__(self):
-        """Return the internal state of the masked array, for pickling purposes.
+        """Return the internal state of the masked array.
+
+        This is for pickling.
 
         """
         state = (1,
@@ -431,11 +479,13 @@ The fieldname base is either `_data` or `_mask`."""
                  self._fill_value,
                  )
         return state
-    #
+
     def __setstate__(self, state):
-        """Restore the internal state of the masked array, for pickling purposes.
-    ``state`` is typically the output of the ``__getstate__`` output, and is a
-    5-tuple:
+        """
+        Restore the internal state of the masked array.
+
+        This is for pickling.  ``state`` is typically the output of the
+        ``__getstate__`` output, and is a 5-tuple:
 
         - class name
         - a tuple giving the shape of the data
@@ -449,9 +499,10 @@ The fieldname base is either `_data` or `_mask`."""
         mdtype = dtype([(k, bool_) for (k, _) in self.dtype.descr])
         self.__dict__['_mask'].__setstate__((shp, mdtype, isf, msk))
         self.fill_value = flv
-    #
+
     def __reduce__(self):
-        """Return a 3-tuple for pickling a MaskedArray.
+        """
+        Return a 3-tuple for pickling a MaskedArray.
 
         """
         return (_mrreconstruct,
@@ -459,27 +510,27 @@ The fieldname base is either `_data` or `_mask`."""
                 self.__getstate__())
 
 def _mrreconstruct(subtype, baseclass, baseshape, basetype,):
-    """Internal function that builds a new MaskedArray from the
-    information stored in a pickle.
+    """
+    Build a new MaskedArray from the information stored in a pickle.
 
     """
     _data = ndarray.__new__(baseclass, baseshape, basetype).view(subtype)
-#    _data._mask = ndarray.__new__(ndarray, baseshape, 'b1')
-#    return _data
     _mask = ndarray.__new__(ndarray, baseshape, 'b1')
     return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
 
-
 mrecarray = MaskedRecords
 
-#####---------------------------------------------------------------------------
-#---- --- Constructors ---
-#####---------------------------------------------------------------------------
+
+###############################################################################
+#                             Constructors                                    #
+###############################################################################
+
 
 def fromarrays(arraylist, dtype=None, shape=None, formats=None,
                names=None, titles=None, aligned=False, byteorder=None,
                fill_value=None):
-    """Creates a mrecarray from a (flat) list of masked arrays.
+    """
+    Creates a mrecarray from a (flat) list of masked arrays.
 
     Parameters
     ----------
@@ -504,6 +555,7 @@ def fromarrays(arraylist, dtype=None, shape=None, formats=None,
     Notes
     -----
     Lists of tuples should be preferred over lists of lists for faster processing.
+
     """
     datalist = [getdata(x) for x in arraylist]
     masklist = [np.atleast_1d(getmaskarray(x)) for x in arraylist]
@@ -517,11 +569,11 @@ def fromarrays(arraylist, dtype=None, shape=None, formats=None,
     return _array
 
 
-#..............................................................................
 def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
                 titles=None, aligned=False, byteorder=None,
                 fill_value=None, mask=nomask):
-    """Creates a MaskedRecords from a list of records.
+    """
+    Creates a MaskedRecords from a list of records.
 
     Parameters
     ----------
@@ -548,14 +600,11 @@ def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
     Notes
     -----
     Lists of tuples should be preferred over lists of lists for faster processing.
+
     """
     # Grab the initial _fieldmask, if needed:
     _mask = getattr(reclist, '_mask', None)
-    # Get the list of records.....
-    try:
-        nfields = len(reclist[0])
-    except TypeError:
-        nfields = len(reclist[0].dtype)
+    # Get the list of records.
     if isinstance(reclist, ndarray):
         # Make sure we don't have some hidden mask
         if isinstance(reclist, MaskedArray):
@@ -584,19 +633,24 @@ def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
         mrec._mask[:] = _mask
     return mrec
 
+
 def _guessvartypes(arr):
-    """Tries to guess the dtypes of the str_ ndarray `arr`, by testing element-wise
-conversion. Returns a list of dtypes.
-The array is first converted to ndarray. If the array is 2D, the test is performed
-on the first line. An exception is raised if the file is 3D or more.
+    """
+    Tries to guess the dtypes of the str_ ndarray `arr`.
+
+    Guesses by testing element-wise conversion. Returns a list of dtypes.
+    The array is first converted to ndarray. If the array is 2D, the test
+    is performed on the first line. An exception is raised if the file is
+    3D or more.
+
     """
     vartypes = []
     arr = np.asarray(arr)
-    if len(arr.shape) == 2 :
+    if len(arr.shape) == 2:
         arr = arr[0]
     elif len(arr.shape) > 2:
         raise ValueError("The array should be 2D at most!")
-    # Start the conversion loop .......
+    # Start the conversion loop.
     for f in arr:
         try:
             int(f)
@@ -605,7 +659,7 @@ on the first line. An exception is raised if the file is 3D or more.
                 float(f)
             except ValueError:
                 try:
-                    val = complex(f)
+                    complex(f)
                 except ValueError:
                     vartypes.append(arr.dtype)
                 else:
@@ -616,9 +670,13 @@ on the first line. An exception is raised if the file is 3D or more.
             vartypes.append(np.dtype(int))
     return vartypes
 
+
 def openfile(fname):
-    "Opens the file handle of file `fname`"
-    # A file handle ...................
+    """
+    Opens the file handle of file `fname`.
+
+    """
+    # A file handle
     if hasattr(fname, 'readline'):
         return fname
     # Try to open the file and guess its type
@@ -635,7 +693,8 @@ def openfile(fname):
 
 def fromtextfile(fname, delimitor=None, commentchar='#', missingchar='',
                  varnames=None, vartypes=None):
-    """Creates a mrecarray from data stored in the file `filename`.
+    """
+    Creates a mrecarray from data stored in the file `filename`.
 
     Parameters
     ----------
@@ -657,12 +716,12 @@ def fromtextfile(fname, delimitor=None, commentchar='#', missingchar='',
 
 
     Ultra simple: the varnames are in the header, one line"""
-    # Try to open the file ......................
-    f = openfile(fname)
+    # Try to open the file.
+    ftext = openfile(fname)
 
     # Get the first non-empty line as the varnames
     while True:
-        line = f.readline()
+        line = ftext.readline()
         firstline = line[:line.find(commentchar)].strip()
         _varnames = firstline.split(delimitor)
         if len(_varnames) > 1:
@@ -670,13 +729,13 @@ def fromtextfile(fname, delimitor=None, commentchar='#', missingchar='',
     if varnames is None:
         varnames = _varnames
 
-    # Get the data ..............................
-    _variables = masked_array([line.strip().split(delimitor) for line in f
-                                  if line[0] != commentchar and len(line) > 1])
+    # Get the data.
+    _variables = masked_array([line.strip().split(delimitor) for line in ftext
+                               if line[0] != commentchar and len(line) > 1])
     (_, nfields) = _variables.shape
-    f.close()
+    ftext.close()
 
-    # Try to guess the dtype ....................
+    # Try to guess the dtype.
     if vartypes is None:
         vartypes = _guessvartypes(_variables[0])
     else:
@@ -687,11 +746,11 @@ def fromtextfile(fname, delimitor=None, commentchar='#', missingchar='',
             warnings.warn(msg % (len(vartypes), nfields))
             vartypes = _guessvartypes(_variables[0])
 
-    # Construct the descriptor ..................
+    # Construct the descriptor.
     mdescr = [(n, f) for (n, f) in zip(varnames, vartypes)]
     mfillv = [ma.default_fill_value(f) for f in vartypes]
 
-    # Get the data and the mask .................
+    # Get the data and the mask.
     # We just need a list of masked_arrays. It's easier to create it like that:
     _mask = (_variables.T == missingchar)
     _datalist = [masked_array(a, mask=m, dtype=t, fill_value=f)
@@ -699,18 +758,21 @@ def fromtextfile(fname, delimitor=None, commentchar='#', missingchar='',
 
     return fromarrays(_datalist, dtype=mdescr)
 
-#....................................................................
+
 def addfield(mrecord, newfield, newfieldname=None):
-    """Adds a new field to the masked record array, using `newfield` as data
-and `newfieldname` as name. If `newfieldname` is None, the new field name is
-set to 'fi', where `i` is the number of existing fields.
+    """Adds a new field to the masked record array
+
+    Uses `newfield` as data and `newfieldname` as name. If `newfieldname`
+    is None, the new field name is set to 'fi', where `i` is the number of
+    existing fields.
+
     """
     _data = mrecord._data
     _mask = mrecord._mask
     if newfieldname is None or newfieldname in reserved_fields:
         newfieldname = 'f%i' % len(_data.dtype)
     newfield = ma.array(newfield)
-    # Get the new data ............
+    # Get the new data.
     # Create a new empty recarray
     newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)])
     newdata = recarray(_data.shape, newdtype)
@@ -720,7 +782,7 @@ set to 'fi', where `i` is the number of existing fields.
     # Add the new field
     newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname])
     newdata = newdata.view(MaskedRecords)
-    # Get the new mask .............
+    # Get the new mask
     # Create a new empty recarray
     newmdtype = np.dtype([(n, bool_) for n in newdtype.names])
     newmask = recarray(_data.shape, newmdtype)
diff --git a/numpy/ma/setup.py b/numpy/ma/setup.py
index 5486ff46a..d1d6c89b5 100644
--- a/numpy/ma/setup.py
+++ b/numpy/ma/setup.py
@@ -1,13 +1,6 @@
 #!/usr/bin/env python
 from __future__ import division, print_function
 
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__     = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
-import os
-
 def configuration(parent_package='',top_path=None):
     from numpy.distutils.misc_util import Configuration
     config = Configuration('ma', parent_package, top_path)
diff --git a/numpy/ma/tests/test_core.py b/numpy/ma/tests/test_core.py
index ce6cddac7..d3ec70488 100644
--- a/numpy/ma/tests/test_core.py
+++ b/numpy/ma/tests/test_core.py
@@ -9,25 +9,43 @@ from __future__ import division, absolute_import, print_function
 __author__ = "Pierre GF Gerard-Marchant"
 
 import warnings
-import sys
 import pickle
-from functools import reduce
 import operator
-
-from nose.tools import assert_raises
+from functools import reduce
 
 import numpy as np
 import numpy.ma.core
 import numpy.core.fromnumeric as fromnumeric
+import numpy.core.umath as umath
+from numpy.testing import TestCase, run_module_suite, assert_raises
 from numpy import ndarray
-from numpy.ma.testutils import *
-from numpy.ma.core import *
 from numpy.compat import asbytes, asbytes_nested
+from numpy.ma.testutils import (
+    assert_, assert_array_equal, assert_equal, assert_almost_equal,
+    assert_equal_records, fail_if_equal, assert_not_equal,
+    assert_mask_equal,
+    )
+from numpy.ma.core import (
+    MAError, MaskError, MaskType, MaskedArray, abs, absolute, add, all,
+    allclose, allequal, alltrue, angle, anom, arange, arccos, arctan2,
+    arcsin, arctan, argsort, array, asarray, choose, concatenate,
+    conjugate, cos, cosh, count, default_fill_value, diag, divide, empty,
+    empty_like, equal, exp, flatten_mask, filled, fix_invalid,
+    flatten_structured_array, fromflex, getmask, getmaskarray, greater,
+    greater_equal, identity, inner, isMaskedArray, less, less_equal, log,
+    log10, make_mask, make_mask_descr, mask_or, masked, masked_array,
+    masked_equal, masked_greater, masked_greater_equal, masked_inside,
+    masked_less, masked_less_equal, masked_not_equal, masked_outside,
+    masked_print_option, masked_values, masked_where, max, maximum,
+    maximum_fill_value, min, minimum, minimum_fill_value, mod, multiply,
+    mvoid, nomask, not_equal, ones, outer, power, product, put, putmask,
+    ravel, repeat, reshape, resize, shape, sin, sinh, sometrue, sort, sqrt,
+    subtract, sum, take, tan, tanh, transpose, where, zeros,
+    )
 
 pi = np.pi
 
 
-#..............................................................................
 class TestMaskedArray(TestCase):
     # Base test class for MaskedArrays.
 
@@ -95,7 +113,7 @@ class TestMaskedArray(TestCase):
             xm.shape = s
             ym.shape = s
             xf.shape = s
-            #
+
             self.assertTrue(not isMaskedArray(x))
             self.assertTrue(isMaskedArray(xm))
             assert_equal(shape(xm), s)
@@ -126,7 +144,7 @@ class TestMaskedArray(TestCase):
         xmym = concatenate((xm, ym), 1)
         assert_equal(np.concatenate((x, y), 1), xmym)
         assert_equal(np.concatenate((xm.mask, ym.mask), 1), xmym._mask)
-        #
+
         x = zeros(2)
         y = array(ones(2), mask=[False, True])
         z = concatenate((x, y))
@@ -141,7 +159,7 @@ class TestMaskedArray(TestCase):
         data = masked_array(list(zip(np.random.rand(10),
                                      np.arange(10))),
                             dtype=[('a', float), ('b', int)])
-        #
+
         test = concatenate([data[:5], data[5:]])
         assert_equal_records(test, data)
 
@@ -177,7 +195,7 @@ class TestMaskedArray(TestCase):
         data = array((x, x[::-1]))
         assert_equal(data, [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0]])
         assert_equal(data._mask, [[1, 0, 0, 0, 0], [0, 0, 0, 0, 1]])
-        #
+
         x.mask = nomask
         data = array((x, x[::-1]))
         assert_equal(data, [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0]])
@@ -221,7 +239,7 @@ class TestMaskedArray(TestCase):
         a[0] = x
         assert_equal(a[0], x)
         self.assertTrue(a[0] is x)
-        #
+
         import datetime
         dt = datetime.datetime.now()
         a[0] = dt
@@ -234,7 +252,8 @@ class TestMaskedArray(TestCase):
         x3 = array(x1, mask=[0, 1, 0, 1])
         x4 = array(x1)
         # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
+        str(x2)  # raises?
+        repr(x2)  # raises?
         assert_equal(np.sort(x1), sort(x2, endwith=False))
         # tests of indexing
         assert_(type(x2[1]) is type(x1[1]))
@@ -283,8 +302,8 @@ class TestMaskedArray(TestCase):
         x3 = array(x1, mask=[[0, 1, 0], [1, 0, 0]])
         x4 = array(x1)
         # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
-        # assert_equal(np.sort(x1), sort(x2, endwith=False))
+        str(x2)  # raises?
+        repr(x2)  # raises?
         # tests of indexing
         assert_(type(x2[1, 0]) is type(x1[1, 0]))
         assert_(x1[1, 0] == x2[1, 0])
@@ -372,7 +391,7 @@ class TestMaskedArray(TestCase):
         y9 = x4.copy()
         assert_equal(y9._data, x4._data)
         assert_equal(y9._mask, x4._mask)
-        #
+
         x = masked_array([1, 2, 3], mask=[0, 1, 0])
         # Copy is False by default
         y = masked_array(x)
@@ -388,11 +407,11 @@ class TestMaskedArray(TestCase):
         copied = deepcopy(a)
         assert_equal(copied.mask, a.mask)
         assert_not_equal(id(a._mask), id(copied._mask))
-        #
+
         copied[1] = 1
         assert_equal(copied.mask, [0, 0, 0])
         assert_equal(a.mask, [0, 1, 0])
-        #
+
         copied = deepcopy(a)
         assert_equal(copied.mask, a.mask)
         copied.mask[1] = False
@@ -463,11 +482,11 @@ class TestMaskedArray(TestCase):
         assert_equal(1, int(array([[[1]]])))
         assert_equal(1.0, float(array([[1]])))
         self.assertRaises(TypeError, float, array([1, 1]))
-        #
+
         with warnings.catch_warnings():
             warnings.simplefilter('ignore', UserWarning)
             assert_(np.isnan(float(array([1], mask=[1]))))
-        #
+
         a = array([1, 2, 3], mask=[1, 0, 0])
         self.assertRaises(TypeError, lambda:float(a))
         assert_equal(float(a[-1]), 3.)
@@ -487,14 +506,14 @@ class TestMaskedArray(TestCase):
         assert_equal(z.imag, 10 * x)
         assert_equal((z * conjugate(z)).real, 101 * x * x)
         z.imag[...] = 0.0
-        #
+
         x = arange(10)
         x[3] = masked
         assert_(str(x[3]) == str(masked))
         c = x >= 8
         assert_(count(where(c, masked, masked)) == 0)
         assert_(shape(where(c, masked, masked)) == c.shape)
-        #
+
         z = masked_where(c, x)
         assert_(z.dtype is x.dtype)
         assert_(z[3] is masked)
@@ -565,7 +584,7 @@ class TestMaskedArray(TestCase):
         test = a.filled(0)
         control = np.array([(1, (0, 1)), (2, (2, 0))], dtype=ndtype)
         assert_equal(test, control)
-        #
+
         test = a['B'].filled(0)
         control = np.array([(0, 1), (2, 0)], dtype=a['B'].dtype)
         assert_equal(test, control)
@@ -637,10 +656,10 @@ class TestMaskedArray(TestCase):
         a = np.array([(1, 2,)], dtype=ndtype)[0]
         f = mvoid(a)
         assert_(isinstance(f, mvoid))
-        #
+
         a = masked_array([(1, 2)], mask=[(1, 0)], dtype=ndtype)[0]
         assert_(isinstance(a, mvoid))
-        #
+
         a = masked_array([(1, 2), (1, 2)], mask=[(1, 0), (0, 0)], dtype=ndtype)
         f = mvoid(a._data[0], a._mask[0])
         assert_(isinstance(f, mvoid))
@@ -698,7 +717,6 @@ class TestMaskedArray(TestCase):
         assert mx2[0] == 0.
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayArithmetic(TestCase):
     # Base test class for MaskedArrays.
 
@@ -761,15 +779,15 @@ class TestMaskedArrayArithmetic(TestCase):
         x = arange(6, dtype=float)
         x.shape = (2, 3)
         y = arange(3, dtype=float)
-        #
+
         z = x / y
         assert_equal(z, [[-1., 1., 1.], [-1., 4., 2.5]])
         assert_equal(z.mask, [[1, 0, 0], [1, 0, 0]])
-        #
+
         z = x / y[None,:]
         assert_equal(z, [[-1., 1., 1.], [-1., 4., 2.5]])
         assert_equal(z.mask, [[1, 0, 0], [1, 0, 0]])
-        #
+
         y = arange(2, dtype=float)
         z = x / y[:, None]
         assert_equal(z, [[-1., -1., -1.], [3., 4., 5.]])
@@ -880,7 +898,7 @@ class TestMaskedArrayArithmetic(TestCase):
         assert_equal([1, 2], res)
         assert_(getmask(res) is nomask)
 
-        ott= array([0., 1., 2., 3.])
+        ott = array([0., 1., 2., 3.])
         res = count(ott, 0)
         assert_(isinstance(res, ndarray))
         assert_(res.dtype.type is np.intp)
@@ -896,7 +914,7 @@ class TestMaskedArrayArithmetic(TestCase):
         # following are true because of careful selection of data
         assert_equal(max(xr), maximum(xmr))
         assert_equal(min(xr), minimum(xmr))
-        #
+
         assert_equal(minimum([1, 2, 3], [4, 0, 9]), [1, 0, 3])
         assert_equal(maximum([1, 2, 3], [4, 0, 9]), [4, 2, 9])
         x = arange(5)
@@ -907,7 +925,7 @@ class TestMaskedArrayArithmetic(TestCase):
         assert_equal(maximum(x, y), where(greater(x, y), x, y))
         assert_(minimum(x) == 0)
         assert_(maximum(x) == 4)
-        #
+
         x = arange(4).reshape(2, 2)
         x[-1, -1] = masked
         assert_equal(maximum(x), 2)
@@ -917,15 +935,15 @@ class TestMaskedArrayArithmetic(TestCase):
         aminimum = minimum(a, a)
         self.assertTrue(isinstance(aminimum, MaskedArray))
         assert_equal(aminimum, np.minimum(a, a))
-        #
+
         aminimum = minimum.outer(a, a)
         self.assertTrue(isinstance(aminimum, MaskedArray))
         assert_equal(aminimum, np.minimum.outer(a, a))
-        #
+
         amaximum = maximum(a, a)
         self.assertTrue(isinstance(amaximum, MaskedArray))
         assert_equal(amaximum, np.maximum(a, a))
-        #
+
         amaximum = maximum.outer(a, a)
         self.assertTrue(isinstance(amaximum, MaskedArray))
         assert_equal(amaximum, np.maximum.outer(a, a))
@@ -975,7 +993,7 @@ class TestMaskedArrayArithmetic(TestCase):
         self.assertTrue(xm[0].ptp() is masked)
         self.assertTrue(xm[0].ptp(0) is masked)
         self.assertTrue(xm[0].ptp(-1) is masked)
-        #
+
         x = array([1, 2, 3], mask=True)
         self.assertTrue(x.min() is masked)
         self.assertTrue(x.max() is masked)
@@ -1006,21 +1024,21 @@ class TestMaskedArrayArithmetic(TestCase):
         # Test binary operations on 2D data
         a = array([[1.], [2.], [3.]], mask=[[False], [True], [True]])
         b = array([[2., 3.], [4., 5.], [6., 7.]])
-        #
+
         test = a * b
         control = array([[2., 3.], [2., 2.], [3., 3.]],
                         mask=[[0, 0], [1, 1], [1, 1]])
         assert_equal(test, control)
         assert_equal(test.data, control.data)
         assert_equal(test.mask, control.mask)
-        #
+
         test = b * a
         control = array([[2., 3.], [4., 5.], [6., 7.]],
                         mask=[[0, 0], [1, 1], [1, 1]])
         assert_equal(test, control)
         assert_equal(test.data, control.data)
         assert_equal(test.mask, control.mask)
-        #
+
         a = array([[1.], [2.], [3.]])
         b = array([[2., 3.], [4., 5.], [6., 7.]],
                   mask=[[0, 0], [0, 0], [0, 1]])
@@ -1030,7 +1048,7 @@ class TestMaskedArrayArithmetic(TestCase):
         assert_equal(test, control)
         assert_equal(test.data, control.data)
         assert_equal(test.mask, control.mask)
-        #
+
         test = b * a
         control = array([[2, 3], [8, 10], [18, 7]],
                         mask=[[0, 0], [0, 0], [0, 1]])
@@ -1042,21 +1060,21 @@ class TestMaskedArrayArithmetic(TestCase):
         # Test domained binary operations on 2D data
         a = array([[1.], [2.], [3.]], mask=[[False], [True], [True]])
         b = array([[2., 3.], [4., 5.], [6., 7.]])
-        #
+
         test = a / b
         control = array([[1. / 2., 1. / 3.], [2., 2.], [3., 3.]],
                         mask=[[0, 0], [1, 1], [1, 1]])
         assert_equal(test, control)
         assert_equal(test.data, control.data)
         assert_equal(test.mask, control.mask)
-        #
+
         test = b / a
         control = array([[2. / 1., 3. / 1.], [4., 5.], [6., 7.]],
                         mask=[[0, 0], [1, 1], [1, 1]])
         assert_equal(test, control)
         assert_equal(test.data, control.data)
         assert_equal(test.mask, control.mask)
-        #
+
         a = array([[1.], [2.], [3.]])
         b = array([[2., 3.], [4., 5.], [6., 7.]],
                   mask=[[0, 0], [0, 0], [0, 1]])
@@ -1066,7 +1084,7 @@ class TestMaskedArrayArithmetic(TestCase):
         assert_equal(test, control)
         assert_equal(test.data, control.data)
         assert_equal(test.mask, control.mask)
-        #
+
         test = b / a
         control = array([[2 / 1., 3 / 1.], [4 / 2., 5 / 2.], [6 / 3., 7]],
                         mask=[[0, 0], [0, 0], [0, 1]])
@@ -1135,9 +1153,9 @@ class TestMaskedArrayArithmetic(TestCase):
     def test_methods_with_output(self):
         xm = array(np.random.uniform(0, 10, 12)).reshape(3, 4)
         xm[:, 0] = xm[0] = xm[-1, -1] = masked
-        #
+
         funclist = ('sum', 'prod', 'var', 'std', 'max', 'min', 'ptp', 'mean',)
-        #
+
         for funcname in funclist:
             npfunc = getattr(np, funcname)
             xmmeth = getattr(xm, funcname)
@@ -1148,7 +1166,7 @@ class TestMaskedArrayArithmetic(TestCase):
             # ... the result should be the given output
             assert_(result is output)
             assert_equal(result, xmmeth(axis=0, out=output))
-            #
+
             output = empty(4, dtype=int)
             result = xmmeth(axis=0, out=output)
             assert_(result is output)
@@ -1187,8 +1205,9 @@ class TestMaskedArrayArithmetic(TestCase):
         assert_equal(test.mask, [False, False])
 
     def test_eq_w_None(self):
-        # Really, comparisons with None should not be done, but
-        # check them anyway
+        # Really, comparisons with None should not be done, but check them
+        # anyway. Note that pep8 will flag these tests.
+
         # With partial mask
         a = array([1, 2], mask=[0, 1])
         assert_equal(a == None, False)
@@ -1219,19 +1238,18 @@ class TestMaskedArrayArithmetic(TestCase):
         a = masked_array([-1, 0, 1, 2, 3], mask=[0, 0, 0, 0, 1])
         control = masked_array([np.nan, np.nan, 0, np.log(2), -1],
                                mask=[1, 1, 0, 0, 1])
-        #
+
         test = log(a)
         assert_equal(test, control)
         assert_equal(test.mask, control.mask)
         assert_equal(a.mask, [0, 0, 0, 0, 1])
-        #
+
         test = np.log(a)
         assert_equal(test, control)
         assert_equal(test.mask, control.mask)
         assert_equal(a.mask, [0, 0, 0, 0, 1])
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayAttributes(TestCase):
 
     def test_keepmask(self):
@@ -1292,7 +1310,7 @@ class TestMaskedArrayAttributes(TestCase):
         xh[filled(xh > 1, False)] = 5
         assert_equal(xh._data, [0, 1, 2, 5, 5])
         assert_equal(xh._mask, [1, 1, 1, 0, 0])
-        #
+
         xh = array([[1, 2], [3, 4]], mask=[[1, 0], [0, 0]], hard_mask=True)
         xh[0] = 0
         assert_equal(xh._data, [[1, 0], [3, 4]])
@@ -1407,7 +1425,7 @@ class TestMaskedArrayAttributes(TestCase):
 
         m = np.ma.array(a)
         m.dtype = np.dtype('f4')
-        repr(m) # raises?
+        repr(m)  # raises?
         assert_equal(m.dtype, np.dtype('f4'))
 
         # check that dtype changes that change shape of mask too much
@@ -1417,7 +1435,7 @@ class TestMaskedArrayAttributes(TestCase):
             m.dtype = np.dtype('f8')
         assert_raises(ValueError, assign)
 
-        b = a.view(dtype='f4', type=np.ma.MaskedArray) # raises?
+        b = a.view(dtype='f4', type=np.ma.MaskedArray)  # raises?
         assert_equal(b.dtype, np.dtype('f4'))
 
         # check that nomask is preserved
@@ -1428,18 +1446,17 @@ class TestMaskedArrayAttributes(TestCase):
         assert_equal(m._mask, np.ma.nomask)
 
 
-#------------------------------------------------------------------------------
 class TestFillingValues(TestCase):
 
     def test_check_on_scalar(self):
         # Test _check_fill_value set to valid and invalid values
         _check_fill_value = np.ma.core._check_fill_value
-        #
+
         fval = _check_fill_value(0, int)
         assert_equal(fval, 0)
         fval = _check_fill_value(None, int)
         assert_equal(fval, default_fill_value(0))
-        #
+
         fval = _check_fill_value(0, "|S3")
         assert_equal(fval, asbytes("0"))
         fval = _check_fill_value(None, "|S3")
@@ -1502,20 +1519,20 @@ class TestFillingValues(TestCase):
         # properly dealt with
         a = array(asbytes_nested(['3', '4', '5']))
         a._optinfo.update({'comment':"updated!"})
-        #
+
         b = array(a, dtype=int)
         assert_equal(b._data, [3, 4, 5])
         assert_equal(b.fill_value, default_fill_value(0))
-        #
+
         b = array(a, dtype=float)
         assert_equal(b._data, [3, 4, 5])
         assert_equal(b.fill_value, default_fill_value(0.))
-        #
+
         b = a.astype(int)
         assert_equal(b._data, [3, 4, 5])
         assert_equal(b.fill_value, default_fill_value(0))
         assert_equal(b._optinfo['comment'], "updated!")
-        #
+
         b = a.astype([('a', '|S3')])
         assert_equal(b['a']._data, a._data)
         assert_equal(b['a'].fill_value, a.fill_value)
@@ -1525,19 +1542,19 @@ class TestFillingValues(TestCase):
         data = masked_array([1, 2, 3], fill_value=-999)
         series = data[[0, 2, 1]]
         assert_equal(series._fill_value, data._fill_value)
-        #
+
         mtype = [('f', float), ('s', '|S3')]
         x = array([(1, 'a'), (2, 'b'), (pi, 'pi')], dtype=mtype)
         x.fill_value = 999
         assert_equal(x.fill_value.item(), [999., asbytes('999')])
         assert_equal(x['f'].fill_value, 999)
         assert_equal(x['s'].fill_value, asbytes('999'))
-        #
+
         x.fill_value = (9, '???')
         assert_equal(x.fill_value.item(), (9, asbytes('???')))
         assert_equal(x['f'].fill_value, 9)
         assert_equal(x['s'].fill_value, asbytes('???'))
-        #
+
         x = array([1, 2, 3.1])
         x.fill_value = 999
         assert_equal(np.asarray(x.fill_value).dtype, float)
@@ -1560,7 +1577,7 @@ class TestFillingValues(TestCase):
         assert_equal(_check_fill_value(None, ndtype), control)
         control = np.array((0,), dtype=[('f0', float)]).astype(ndtype)
         assert_equal(_check_fill_value(0, ndtype), control)
-        #
+
         ndtype = np.dtype("int, (2,3)float, float")
         control = np.array((default_fill_value(0),
                             default_fill_value(0.),
@@ -1594,13 +1611,13 @@ class TestFillingValues(TestCase):
         assert_equal(test['A'], default_fill_value(a['A']))
         assert_equal(test['B']['BA'], default_fill_value(a['B']['BA']))
         assert_equal(test['B']['BB'], default_fill_value(a['B']['BB']))
-        #
+
         test = minimum_fill_value(a)
         assert_equal(test[0], minimum_fill_value(a['A']))
         assert_equal(test[1][0], minimum_fill_value(a['B']['BA']))
         assert_equal(test[1][1], minimum_fill_value(a['B']['BB']))
         assert_equal(test[1], minimum_fill_value(a['B']))
-        #
+
         test = maximum_fill_value(a)
         assert_equal(test[0], maximum_fill_value(a['A']))
         assert_equal(test[1][0], maximum_fill_value(a['B']['BA']))
@@ -1643,13 +1660,13 @@ class TestFillingValues(TestCase):
         # Test adding a fill_value parameter to empty/ones/zeros
         a = empty(3, fill_value=999.)
         assert_equal(a.fill_value, 999.)
-        #
+
         a = ones(3, fill_value=999., dtype=float)
         assert_equal(a.fill_value, 999.)
-        #
+
         a = zeros(3, fill_value=0., dtype=complex)
         assert_equal(a.fill_value, 0.)
-        #
+
         a = identity(3, fill_value=0., dtype=complex)
         assert_equal(a.fill_value, 0.)
 
@@ -1696,7 +1713,6 @@ class TestFillingValues(TestCase):
         assert_(y.fill_value == 999999)
 
 
-#------------------------------------------------------------------------------
 class TestUfuncs(TestCase):
     # Test class for the application of ufuncs on MaskedArrays.
 
@@ -1816,7 +1832,6 @@ class TestUfuncs(TestCase):
         assert_(a / me_too == "Me2rdiv")
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayInPlaceArithmetics(TestCase):
     # Test MaskedArray Arithmetics
 
@@ -1843,7 +1858,7 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
         assert_equal(x, y + 1)
         xm += 1
         assert_equal(xm, y + 1)
-        #
+
         (x, _, xm) = self.floatdata
         id1 = x.data.ctypes._data
         x += 1.
@@ -1934,20 +1949,20 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
         assert_equal(xm.mask, mask_or(mask_or(m, a.mask), (a == 0)))
 
     def test_inplace_division_misc(self):
-        #
+
         x = [1., 1., 1., -2., pi / 2., 4., 5., -10., 10., 1., 2., 3.]
         y = [5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
         m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
-        #
+
         z = xm / ym
         assert_equal(z._mask, [1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1])
         assert_equal(z._data,
                      [1., 1., 1., -1., -pi / 2., 4., 5., 1., 1., 1., 2., 3.])
         #assert_equal(z._data, [0.2,1.,1./3.,-1.,-pi/2.,-1.,5.,1.,1.,1.,2.,1.])
-        #
+
         xm = xm.copy()
         xm /= ym
         assert_equal(xm._mask, [1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1])
@@ -2066,7 +2081,7 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
         assert_equal(a, [[2, 2], [4, 4]])
         if a.mask is not nomask:
             assert_equal(a.mask, [[0, 0], [0, 0]])
-        #
+
         a = array([[1, 1], [3, 3]])
         b = array([1, 1], mask=[0, 1])
         a += b
@@ -2080,7 +2095,7 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
         assert_equal(a, [[0, 0], [2, 2]])
         if a.mask is not nomask:
             assert_equal(a.mask, [[0, 0], [0, 0]])
-        #
+
         a = array([[1, 1], [3, 3]])
         b = array([1, 1], mask=[0, 1])
         a -= b
@@ -2094,7 +2109,7 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
         assert_equal(a, [[1, 1], [3, 3]])
         if a.mask is not nomask:
             assert_equal(a.mask, [[0, 0], [0, 0]])
-        #
+
         a = array([[1, 1], [3, 3]])
         b = array([1, 1], mask=[0, 1])
         a *= b
@@ -2145,7 +2160,6 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
 
                 assert_equal(len(w), 0, "Failed on type=%s." % t)
 
-
     def test_inplace_subtraction_array_type(self):
         # Test of inplace subtractions
         for t in self.othertypes:
@@ -2322,7 +2336,6 @@ class TestMaskedArrayInPlaceArithmetics(TestCase):
                 assert_equal(len(w), 0, "Failed on type=%s." % t)
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayMethods(TestCase):
     # Test class for miscellaneous MaskedArrays methods.
     def setUp(self):
@@ -2368,7 +2381,7 @@ class TestMaskedArrayMethods(TestCase):
         assert_equal(a.compress([1, 0, 1]), a._data.compress([1, 0, 1]))
         assert_equal(a.conj(), a._data.conj())
         assert_equal(a.conjugate(), a._data.conjugate())
-        #
+
         m = array([[1, 2], [3, 4]])
         assert_equal(m.diagonal(), m._data.diagonal())
         assert_equal(a.sum(), a._data.sum())
@@ -2410,14 +2423,14 @@ class TestMaskedArrayMethods(TestCase):
         mx = masked_array(x, mask=m)
         mxbig = (mx > 0.5)
         mxsmall = (mx < 0.5)
-        #
+
         self.assertFalse(mxbig.all())
         self.assertTrue(mxbig.any())
         assert_equal(mxbig.all(0), [False, False, True])
         assert_equal(mxbig.all(1), [False, False, True])
         assert_equal(mxbig.any(0), [False, False, True])
         assert_equal(mxbig.any(1), [True, True, True])
-        #
+
         self.assertFalse(mxsmall.all())
         self.assertTrue(mxsmall.any())
         assert_equal(mxsmall.all(0), [True, True, False])
@@ -2436,14 +2449,14 @@ class TestMaskedArrayMethods(TestCase):
         mX = masked_array(X, mask=m)
         mXbig = (mX > 0.5)
         mXsmall = (mX < 0.5)
-        #
+
         self.assertFalse(mXbig.all())
         self.assertTrue(mXbig.any())
         assert_equal(mXbig.all(0), np.matrix([False, False, True]))
         assert_equal(mXbig.all(1), np.matrix([False, False, True]).T)
         assert_equal(mXbig.any(0), np.matrix([False, False, True]))
         assert_equal(mXbig.any(1), np.matrix([True, True, True]).T)
-        #
+
         self.assertFalse(mXsmall.all())
         self.assertTrue(mXsmall.any())
         assert_equal(mXsmall.all(0), np.matrix([True, True, False]))
@@ -2455,13 +2468,13 @@ class TestMaskedArrayMethods(TestCase):
         # Some fun with all and any
         store = empty((), dtype=bool)
         full = array([1, 2, 3], mask=True)
-        #
+
         self.assertTrue(full.all() is masked)
         full.all(out=store)
         self.assertTrue(store)
         self.assertTrue(store._mask, True)
         self.assertTrue(store is not masked)
-        #
+
         store = empty((), dtype=bool)
         self.assertTrue(full.any() is masked)
         full.any(out=store)
@@ -2472,7 +2485,7 @@ class TestMaskedArrayMethods(TestCase):
     def test_argmax_argmin(self):
         # Tests argmin & argmax on MaskedArrays.
         (x, X, XX, m, mx, mX, mXX, m2x, m2X, m2XX) = self.d
-        #
+
         assert_equal(mx.argmin(), 35)
         assert_equal(mX.argmin(), 35)
         assert_equal(m2x.argmin(), 4)
@@ -2481,12 +2494,12 @@ class TestMaskedArrayMethods(TestCase):
         assert_equal(mX.argmax(), 28)
         assert_equal(m2x.argmax(), 31)
         assert_equal(m2X.argmax(), 31)
-        #
+
         assert_equal(mX.argmin(0), [2, 2, 2, 5, 0, 5])
         assert_equal(m2X.argmin(0), [2, 2, 4, 5, 0, 4])
         assert_equal(mX.argmax(0), [0, 5, 0, 5, 4, 0])
         assert_equal(m2X.argmax(0), [5, 5, 0, 5, 1, 0])
-        #
+
         assert_equal(mX.argmin(1), [4, 1, 0, 0, 5, 5, ])
         assert_equal(m2X.argmin(1), [4, 4, 0, 0, 5, 3])
         assert_equal(mX.argmax(1), [2, 4, 1, 1, 4, 1])
@@ -2514,27 +2527,27 @@ class TestMaskedArrayMethods(TestCase):
         a = masked_array([1., 2., 3., 4., 5.], fill_value=9999)
         condition = (a > 1.5) & (a < 3.5)
         assert_equal(a.compress(condition), [2., 3.])
-        #
+
         a[[2, 3]] = masked
         b = a.compress(condition)
         assert_equal(b._data, [2., 3.])
         assert_equal(b._mask, [0, 1])
         assert_equal(b.fill_value, 9999)
         assert_equal(b, a[condition])
-        #
+
         condition = (a < 4.)
         b = a.compress(condition)
         assert_equal(b._data, [1., 2., 3.])
         assert_equal(b._mask, [0, 0, 1])
         assert_equal(b.fill_value, 9999)
         assert_equal(b, a[condition])
-        #
+
         a = masked_array([[10, 20, 30], [40, 50, 60]],
                          mask=[[0, 0, 1], [1, 0, 0]])
         b = a.compress(a.ravel() >= 22)
         assert_equal(b._data, [30, 40, 50, 60])
         assert_equal(b._mask, [1, 1, 0, 0])
-        #
+
         x = np.array([3, 1, 2])
         b = a.compress(x >= 2, axis=1)
         assert_equal(b._data, [[10, 30], [40, 60]])
@@ -2548,7 +2561,7 @@ class TestMaskedArrayMethods(TestCase):
         a[0] = masked
         b = a.compressed()
         assert_equal(b, [2, 3, 4])
-        #
+
         a = array(np.matrix([1, 2, 3, 4]), mask=[0, 0, 0, 0])
         b = a.compressed()
         assert_equal(b, a)
@@ -2563,11 +2576,11 @@ class TestMaskedArrayMethods(TestCase):
         a = masked_array([(1, 1.1, '1.1'), (2, 2.2, '2.2'), (3, 3.3, '3.3')],
                          dtype=datatype)
         assert_equal(len(a.fill_value.item()), len(datatype))
-        #
+
         b = empty_like(a)
         assert_equal(b.shape, a.shape)
         assert_equal(b.fill_value, a.fill_value)
-        #
+
         b = empty(len(a), dtype=datatype)
         assert_equal(b.shape, a.shape)
         assert_equal(b.fill_value, a.fill_value)
@@ -2592,7 +2605,7 @@ class TestMaskedArrayMethods(TestCase):
         self.assertTrue(x[3] is masked)
         self.assertTrue(x[4] is not masked)
         assert_equal(x, [0, 10, 2, -1, 40])
-        #
+
         x = masked_array(arange(10), mask=[1, 0, 0, 0, 0] * 2)
         i = [0, 2, 4, 6]
         x.put(i, [6, 4, 2, 0])
@@ -2601,7 +2614,7 @@ class TestMaskedArrayMethods(TestCase):
         x.put(i, masked_array([0, 2, 4, 6], [1, 0, 1, 0]))
         assert_array_equal(x, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ])
         assert_equal(x.mask, [1, 0, 0, 0, 1, 1, 0, 0, 0, 0])
-        #
+
         x = masked_array(arange(10), mask=[1, 0, 0, 0, 0] * 2)
         put(x, i, [6, 4, 2, 0])
         assert_equal(x, asarray([6, 1, 4, 3, 2, 5, 0, 7, 8, 9, ]))
@@ -2688,28 +2701,28 @@ class TestMaskedArrayMethods(TestCase):
     def test_sort(self):
         # Test sort
         x = array([1, 4, 2, 3], mask=[0, 1, 0, 0], dtype=np.uint8)
-        #
+
         sortedx = sort(x)
         assert_equal(sortedx._data, [1, 2, 3, 4])
         assert_equal(sortedx._mask, [0, 0, 0, 1])
-        #
+
         sortedx = sort(x, endwith=False)
         assert_equal(sortedx._data, [4, 1, 2, 3])
         assert_equal(sortedx._mask, [1, 0, 0, 0])
-        #
+
         x.sort()
         assert_equal(x._data, [1, 2, 3, 4])
         assert_equal(x._mask, [0, 0, 0, 1])
-        #
+
         x = array([1, 4, 2, 3], mask=[0, 1, 0, 0], dtype=np.uint8)
         x.sort(endwith=False)
         assert_equal(x._data, [4, 1, 2, 3])
         assert_equal(x._mask, [1, 0, 0, 0])
-        #
+
         x = [1, 4, 2, 3]
         sortedx = sort(x)
         self.assertTrue(not isinstance(sorted, MaskedArray))
-        #
+
         x = array([0, 1, -1, -2, 2], mask=nomask, dtype=np.int8)
         sortedx = sort(x, endwith=False)
         assert_equal(sortedx._data, [-2, -1, 0, 1, 2])
@@ -2764,7 +2777,7 @@ class TestMaskedArrayMethods(TestCase):
             data=[(3, 3), (3, 2), (2, 2), (2, 1), (1, 0), (1, 1), (1, 2)],
             mask=[(0, 0), (0, 1), (0, 0), (0, 0), (1, 0), (0, 0), (0, 0)],
             dtype=[('A', int), ('B', int)])
-        #
+
         test = sort(a)
         b = array(
             data=[(1, 1), (1, 2), (2, 1), (2, 2), (3, 3), (3, 2), (1, 0)],
@@ -2772,7 +2785,7 @@ class TestMaskedArrayMethods(TestCase):
             dtype=[('A', int), ('B', int)])
         assert_equal(test, b)
         assert_equal(test.mask, b.mask)
-        #
+
         test = sort(a, endwith=False)
         b = array(
             data=[(1, 0), (1, 1), (1, 2), (2, 1), (2, 2), (3, 2), (3, 3), ],
@@ -2812,7 +2825,7 @@ class TestMaskedArrayMethods(TestCase):
                       0, 0, 1, 0, 1, 0])
         mX = array(x, mask=m).reshape(6, 6)
         mXX = mX.reshape(3, 2, 2, 3)
-        #
+
         mXswapped = mX.swapaxes(0, 1)
         assert_equal(mXswapped[-1], mX[:, -1])
 
@@ -2826,7 +2839,7 @@ class TestMaskedArrayMethods(TestCase):
         assert_equal(x.take([0, 0, 3]), x[[0, 0, 3]])
         assert_equal(x.take([[0, 1], [0, 1]]),
                      masked_array([[10, 20], [10, 20]], [[0, 1], [0, 1]]))
-        #
+
         x = array([[10, 20, 30], [40, 50, 60]], mask=[[0, 0, 1], [1, 0, 0, ]])
         assert_equal(x.take([0, 2], axis=1),
                      array([[10, 30], [40, 60]], mask=[[0, 1], [1, 0]]))
@@ -2919,12 +2932,12 @@ class TestMaskedArrayMethods(TestCase):
         record = data.toflex()
         assert_equal(record['_data'], data._data)
         assert_equal(record['_mask'], data._mask)
-        #
+
         data[[0, 1, 2, -1]] = masked
         record = data.toflex()
         assert_equal(record['_data'], data._data)
         assert_equal(record['_mask'], data._mask)
-        #
+
         ndtype = [('i', int), ('s', '|S3'), ('f', float)]
         data = array([(i, s, f) for (i, s, f) in zip(np.arange(10),
                                                      'ABCDEFGHIJKLM',
@@ -2934,7 +2947,7 @@ class TestMaskedArrayMethods(TestCase):
         record = data.toflex()
         assert_equal(record['_data'], data._data)
         assert_equal(record['_mask'], data._mask)
-        #
+
         ndtype = np.dtype("int, (2,3)float, float")
         data = array([(i, f, ff) for (i, f, ff) in zip(np.arange(10),
                                                        np.random.rand(10),
@@ -2951,12 +2964,12 @@ class TestMaskedArrayMethods(TestCase):
         test = fromflex(a.toflex())
         assert_equal(test, a)
         assert_equal(test.mask, a.mask)
-        #
+
         a = array([1, 2, 3], mask=[0, 0, 1])
         test = fromflex(a.toflex())
         assert_equal(test, a)
         assert_equal(test.mask, a.mask)
-        #
+
         a = array([(1, 1.), (2, 2.), (3, 3.)], mask=[(1, 0), (0, 0), (0, 1)],
                   dtype=[('A', int), ('B', float)])
         test = fromflex(a.toflex())
@@ -2970,11 +2983,10 @@ class TestMaskedArrayMethods(TestCase):
                                mask=[0, 0, 1, 0, 0])
         assert_equal(marray.T, control)
         assert_equal(marray.transpose(), control)
-        #
+
         assert_equal(MaskedArray.cumsum(marray.T, 0), control.cumsum(0))
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayMathMethods(TestCase):
 
     def setUp(self):
@@ -3016,7 +3028,7 @@ class TestMaskedArrayMathMethods(TestCase):
         assert_equal(mXcp._data, mX.filled(0).cumsum(0))
         mXcp = mX.cumsum(1)
         assert_equal(mXcp._data, mX.filled(0).cumsum(1))
-        #
+
         mXcp = mX.cumprod(0)
         assert_equal(mXcp._data, mX.filled(1).cumprod(0))
         mXcp = mX.cumprod(1)
@@ -3026,7 +3038,7 @@ class TestMaskedArrayMathMethods(TestCase):
         # Tests cumsum/cumprod w/ output
         xm = array(np.random.uniform(0, 10, 12)).reshape(3, 4)
         xm[:, 0] = xm[0] = xm[-1, -1] = masked
-        #
+
         for funcname in ('cumsum', 'cumprod'):
             npfunc = getattr(np, funcname)
             xmmeth = getattr(xm, funcname)
@@ -3038,7 +3050,7 @@ class TestMaskedArrayMathMethods(TestCase):
             # ... the result should be the given output
             self.assertTrue(result is output)
             assert_equal(result, xmmeth(axis=0, out=output))
-            #
+
             output = empty((3, 4), dtype=int)
             result = xmmeth(axis=0, out=output)
             self.assertTrue(result is output)
@@ -3058,7 +3070,7 @@ class TestMaskedArrayMathMethods(TestCase):
         assert_equal(mX.ptp(1), rows)
 
     def test_add_object(self):
-        x = masked_array(['a', 'b'], mask = [1, 0], dtype=object)
+        x = masked_array(['a', 'b'], mask=[1, 0], dtype=object)
         y = x + 'x'
         assert_equal(y[1], 'bx')
         assert_(y.mask[0])
@@ -3142,7 +3154,7 @@ class TestMaskedArrayMathMethods(TestCase):
         # Test a special case for var
         nout = np.array(-1, dtype=float)
         mout = array(-1, dtype=float)
-        #
+
         x = array(arange(10), mask=True)
         for methodname in ('var', 'std'):
             method = getattr(x, methodname)
@@ -3152,15 +3164,15 @@ class TestMaskedArrayMathMethods(TestCase):
             # Using a masked array as explicit output
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
-                _ = method(out=mout)
+                method(out=mout)
             self.assertTrue(mout is not masked)
             assert_equal(mout.mask, True)
             # Using a ndarray as explicit output
             with warnings.catch_warnings():
                 warnings.simplefilter('ignore')
-                _ = method(out=nout)
+                method(out=nout)
             self.assertTrue(np.isnan(nout))
-        #
+
         x = array(arange(10), mask=True)
         x[-1] = 9
         for methodname in ('var', 'std'):
@@ -3205,25 +3217,24 @@ class TestMaskedArrayMathMethods(TestCase):
     def test_axis_methods_nomask(self):
         # Test the combination nomask & methods w/ axis
         a = array([[1, 2, 3], [4, 5, 6]])
-        #
+
         assert_equal(a.sum(0), [5, 7, 9])
         assert_equal(a.sum(-1), [6, 15])
         assert_equal(a.sum(1), [6, 15])
-        #
+
         assert_equal(a.prod(0), [4, 10, 18])
         assert_equal(a.prod(-1), [6, 120])
         assert_equal(a.prod(1), [6, 120])
-        #
+
         assert_equal(a.min(0), [1, 2, 3])
         assert_equal(a.min(-1), [1, 4])
         assert_equal(a.min(1), [1, 4])
-        #
+
         assert_equal(a.max(0), [4, 5, 6])
         assert_equal(a.max(-1), [3, 6])
         assert_equal(a.max(1), [3, 6])
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayMathMethodsComplex(TestCase):
     # Test class for miscellaneous MaskedArrays methods.
     def setUp(self):
@@ -3277,7 +3288,6 @@ class TestMaskedArrayMathMethodsComplex(TestCase):
                                 mX[:, k].compressed().std())
 
 
-#------------------------------------------------------------------------------
 class TestMaskedArrayFunctions(TestCase):
     # Test class for miscellaneous functions.
 
@@ -3350,7 +3360,7 @@ class TestMaskedArrayFunctions(TestCase):
         # test that masked_where on a structured array sets a structured
         # mask (see issue #2972)
         a = np.zeros(10, dtype=[("A", "<f2"), ("B", "<f4")])
-        am = np.ma.masked_where(a["A"]<5, a)
+        am = np.ma.masked_where(a["A"] < 5, a)
         assert_equal(am.mask.dtype.names, am.dtype.names)
         assert_equal(am["A"],
                     np.ma.masked_array(np.zeros(10), np.ones(10)))
@@ -3407,7 +3417,7 @@ class TestMaskedArrayFunctions(TestCase):
         # ... the result should be the given output
         self.assertTrue(result is output)
         assert_equal(result, xm.round(decimals=2, out=output))
-        #
+
         output = empty((3, 4), dtype=float)
         result = xm.round(decimals=2, out=output)
         self.assertTrue(result is output)
@@ -3445,7 +3455,7 @@ class TestMaskedArrayFunctions(TestCase):
         b1 = np.array([2, 4, 3])
         b2 = np.array([b1, b1])
         b2m = array(b2, mask=[[0, 1, 0], [0, 1, 0]])
-        #
+
         ctrl = array([[1 ** 2, 2 ** 4, 3 ** 3], [4 ** 2, 5 ** 4, 6 ** 3]],
                      mask=[[1, 1, 0], [0, 1, 1]])
         # No broadcasting, base & exp w/ mask
@@ -3460,7 +3470,7 @@ class TestMaskedArrayFunctions(TestCase):
         test = a2 ** b2m
         assert_equal(test, ctrl)
         assert_equal(test.mask, b2m.mask)
-        #
+
         ctrl = array([[2 ** 2, 4 ** 4, 3 ** 3], [2 ** 2, 4 ** 4, 3 ** 3]],
                      mask=[[0, 1, 0], [0, 1, 0]])
         test = b1 ** b2m
@@ -3479,7 +3489,7 @@ class TestMaskedArrayFunctions(TestCase):
         xm = masked_array(x, mask=m1)
         ym = masked_array(y, mask=m2)
         xm.set_fill_value(1e+20)
-        #
+
         d = where(xm > 2, xm, -9)
         assert_equal(d, [-9., -9., -9., -9., -9., 4.,
                          -9., -9., 10., -9., -9., 3.])
@@ -3494,7 +3504,7 @@ class TestMaskedArrayFunctions(TestCase):
         tmp = xm._mask.copy()
         tmp[(xm <= 2).filled(True)] = True
         assert_equal(d._mask, tmp)
-        #
+
         ixm = xm.astype(int)
         d = where(ixm > 2, ixm, masked)
         assert_equal(d, [-9, -9, -9, -9, -9, 4, -9, -9, 10, -9, -9, 3])
@@ -3541,7 +3551,7 @@ class TestMaskedArrayFunctions(TestCase):
         assert_(z[0] is masked)
         assert_(z[1] is not masked)
         assert_(z[2] is masked)
-        #
+
         x = arange(1, 6)
         x[-1] = masked
         y = arange(1, 6) * 10
@@ -3630,7 +3640,7 @@ class TestMaskedArrayFunctions(TestCase):
         b = a.reshape(5, 2, order='F')
         assert_equal(b.shape, (5, 2))
         self.assertTrue(b.flags['F'])
-        #
+
         c = np.reshape(a, (2, 5))
         self.assertTrue(isinstance(c, MaskedArray))
         assert_equal(c.shape, (2, 5))
@@ -3778,32 +3788,39 @@ class TestMaskedArrayFunctions(TestCase):
         a = np.ma.array([1, 2])
         test = np.ma.compressed(a)
         assert_(type(test) is np.ndarray)
+
         # Test case when input data is ndarray subclass
         class A(np.ndarray):
             pass
+
         a = np.ma.array(A(shape=0))
         test = np.ma.compressed(a)
         assert_(type(test) is A)
+
         # Test that compress flattens
         test = np.ma.compressed([[1],[2]])
         assert_equal(test.ndim, 1)
         test = np.ma.compressed([[[[[1]]]]])
         assert_equal(test.ndim, 1)
+
         # Test case when input is MaskedArray subclass
         class M(MaskedArray):
             pass
+
         test = np.ma.compressed(M(shape=(0,1,2)))
         assert_equal(test.ndim, 1)
+
         # with .compessed() overriden
         class M(MaskedArray):
             def compressed(self):
                 return 42
+
         test = np.ma.compressed(M(shape=(0,1,2)))
         assert_equal(test, 42)
 
-#------------------------------------------------------------------------------
+
 class TestMaskedFields(TestCase):
-    #
+
     def setUp(self):
         ilist = [1, 2, 3, 4, 5]
         flist = [1.1, 2.2, 3.3, 4.4, 5.5]
@@ -3867,9 +3884,8 @@ class TestMaskedFields(TestCase):
     def test_mask_element(self):
         "Check record access"
         base = self.data['base']
-        (base_a, base_b, base_c) = (base['a'], base['b'], base['c'])
         base[0] = masked
-        #
+
         for n in ('a', 'b', 'c'):
             assert_equal(base[n].mask, [1, 1, 0, 0, 1])
             assert_equal(base[n]._data, base._data[n])
@@ -3901,7 +3917,7 @@ class TestMaskedFields(TestCase):
         test = a.view((float, 2))
         assert_equal(test, data)
         assert_equal(test.mask, controlmask.reshape(-1, 2))
-        #
+
         test = a.view((float, 2), np.matrix)
         assert_equal(test, data)
         self.assertTrue(isinstance(test, np.matrix))
@@ -3959,9 +3975,8 @@ class TestMaskedFields(TestCase):
             assert_equal(len(rec), len(self.data['ddtype']))
 
 
-#------------------------------------------------------------------------------
 class TestMaskedView(TestCase):
-    #
+
     def setUp(self):
         iterator = list(zip(np.arange(10), np.random.rand(10)))
         data = np.array(iterator)
@@ -3994,18 +4009,18 @@ class TestMaskedView(TestCase):
 
     def test_view_to_flexible_dtype(self):
         (data, a, controlmask) = self.data
-        #
+
         test = a.view([('A', float), ('B', float)])
         assert_equal(test.mask.dtype.names, ('A', 'B'))
         assert_equal(test['A'], a['a'])
         assert_equal(test['B'], a['b'])
-        #
+
         test = a[0].view([('A', float), ('B', float)])
         self.assertTrue(isinstance(test, MaskedArray))
         assert_equal(test.mask.dtype.names, ('A', 'B'))
         assert_equal(test['A'], a['a'][0])
         assert_equal(test['B'], a['b'][0])
-        #
+
         test = a[-1].view([('A', float), ('B', float)])
         self.assertTrue(isinstance(test, MaskedArray))
         assert_equal(test.dtype.names, ('A', 'B'))
@@ -4031,7 +4046,7 @@ class TestMaskedView(TestCase):
 
     def test_view_to_dtype_and_type(self):
         (data, a, controlmask) = self.data
-        #
+
         test = a.view((float, 2), np.matrix)
         assert_equal(test, data)
         self.assertTrue(isinstance(test, np.matrix))
@@ -4081,6 +4096,5 @@ def test_append_masked_array_along_axis():
     assert_array_equal(result.mask, expected.mask)
 
 
-###############################################################################
 if __name__ == "__main__":
     run_module_suite()
diff --git a/numpy/ma/tests/test_extras.py b/numpy/ma/tests/test_extras.py
index 3c7b95c9e..b6d902995 100644
--- a/numpy/ma/tests/test_extras.py
+++ b/numpy/ma/tests/test_extras.py
@@ -9,30 +9,27 @@ Adapted from the original test_ma by Pierre Gerard-Marchant
 """
 from __future__ import division, absolute_import, print_function
 
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__ = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
 import warnings
 
 import numpy as np
-from numpy.testing import (TestCase, run_module_suite, assert_warns,
-                           assert_raises, clear_and_catch_warnings)
-from numpy.ma.testutils import (rand, assert_, assert_array_equal,
-                                assert_equal, assert_almost_equal)
-from numpy.ma.core import (array, arange, masked, MaskedArray, masked_array,
-                           getmaskarray, shape, nomask, ones, zeros, count)
-import numpy.ma.extras as mae
+from numpy.testing import (
+    TestCase, run_module_suite, assert_warns, clear_and_catch_warnings
+    )
+from numpy.ma.testutils import (
+    assert_, assert_array_equal, assert_equal, assert_almost_equal
+    )
+from numpy.ma.core import (
+    array, arange, masked, MaskedArray, masked_array, getmaskarray, shape,
+    nomask, ones, zeros, count
+    )
 from numpy.ma.extras import (
-    atleast_2d, mr_, dot, polyfit,
-    cov, corrcoef, median, average,
-    unique, setxor1d, setdiff1d, union1d, intersect1d, in1d, ediff1d,
-    apply_over_axes, apply_along_axis,
-    compress_nd, compress_rowcols, mask_rowcols,
-    clump_masked, clump_unmasked,
-    flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges,
-    masked_all, masked_all_like)
+    atleast_2d, mr_, dot, polyfit, cov, corrcoef, median, average, unique,
+    setxor1d, setdiff1d, union1d, intersect1d, in1d, ediff1d,
+    apply_over_axes, apply_along_axis, compress_nd, compress_rowcols,
+    mask_rowcols, clump_masked, clump_unmasked, flatnotmasked_contiguous,
+    notmasked_contiguous, notmasked_edges, masked_all, masked_all_like
+    )
+import numpy.ma.extras as mae
 
 
 class TestGeneric(TestCase):
@@ -267,10 +264,10 @@ class TestConcatenator(TestCase):
 
     def test_2d(self):
         # Tests mr_ on 2D arrays.
-        a_1 = rand(5, 5)
-        a_2 = rand(5, 5)
-        m_1 = np.round_(rand(5, 5), 0)
-        m_2 = np.round_(rand(5, 5), 0)
+        a_1 = np.random.rand(5, 5)
+        a_2 = np.random.rand(5, 5)
+        m_1 = np.round_(np.random.rand(5, 5), 0)
+        m_2 = np.round_(np.random.rand(5, 5), 0)
         b_1 = masked_array(a_1, mask=m_1)
         b_2 = masked_array(a_2, mask=m_2)
         # append columns
@@ -358,13 +355,13 @@ class TestCompressFunctions(TestCase):
 
         # axis=None
         a = compress_nd(x)
-        assert_equal(a, [[[ 0,  2,  3 , 4],
+        assert_equal(a, [[[ 0,  2,  3,  4],
                           [10, 12, 13, 14],
                           [15, 17, 18, 19]],
                          [[40, 42, 43, 44],
                           [50, 52, 53, 54],
                           [55, 57, 58, 59]]])
-        
+
         # axis=0
         a = compress_nd(x, 0)
         assert_equal(a, [[[ 0,  1,  2,  3,  4],
@@ -449,8 +446,8 @@ class TestCompressFunctions(TestCase):
 
         # axis=(0, 2)
         a = compress_nd(x, (0, 2))
-        assert_equal(a, [[[ 0,   2,  3,  4],
-                          [ 5,   7,  8,  9],
+        assert_equal(a, [[[ 0,  2,  3,  4],
+                          [ 5,  7,  8,  9],
                           [10, 12, 13, 14],
                           [15, 17, 18, 19]],
                          [[40, 42, 43, 44],
@@ -595,7 +592,7 @@ class TestApplyAlongAxis(TestCase):
         xa = apply_along_axis(myfunc, 2, a)
         assert_equal(xa, [[1, 4], [7, 10]])
 
-   # Tests kwargs functions
+    # Tests kwargs functions
     def test_3d_kwargs(self):
         a = arange(12).reshape(2, 2, 3)
 
@@ -1120,7 +1117,7 @@ class TestArraySetOps(TestCase):
 
 
 class TestShapeBase(TestCase):
-    #
+
     def test_atleast2d(self):
         # Test atleast_2d
         a = masked_array([0, 1, 2], mask=[0, 1, 0])
@@ -1131,7 +1128,5 @@ class TestShapeBase(TestCase):
         assert_equal(a.mask.shape, a.data.shape)
 
 
-###############################################################################
-#------------------------------------------------------------------------------
 if __name__ == "__main__":
     run_module_suite()
diff --git a/numpy/ma/tests/test_mrecords.py b/numpy/ma/tests/test_mrecords.py
index 54945e8f0..84b68ba0f 100644
--- a/numpy/ma/tests/test_mrecords.py
+++ b/numpy/ma/tests/test_mrecords.py
@@ -13,22 +13,22 @@ import pickle
 import numpy as np
 import numpy.ma as ma
 from numpy import recarray
-from numpy.core.records import (fromrecords as recfromrecords,
-                                fromarrays as recfromarrays)
-
 from numpy.compat import asbytes, asbytes_nested
-from numpy.ma.testutils import *
 from numpy.ma import masked, nomask
-from numpy.ma.mrecords import (MaskedRecords, mrecarray, fromarrays,
-                               fromtextfile, fromrecords, addfield)
-
-
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__revision__ = "$Revision: 3473 $"
-__date__ = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
+from numpy.testing import TestCase, run_module_suite
+from numpy.core.records import (
+    fromrecords as recfromrecords, fromarrays as recfromarrays
+    )
+from numpy.ma.mrecords import (
+    MaskedRecords, mrecarray, fromarrays, fromtextfile, fromrecords,
+    addfield
+    )
+from numpy.ma.testutils import (
+    assert_, assert_equal,
+    assert_equal_records,
+    )
 
 
-#..............................................................................
 class TestMRecords(TestCase):
     # Base test class for MaskedArrays.
     def __init__(self, *args, **kwds):
@@ -147,7 +147,7 @@ class TestMRecords(TestCase):
         data = ma.array([('a', 1), ('b', 2), ('c', 3)], dtype=ndtype)
         rdata = data.view(MaskedRecords)
         val = ma.array([10, 20, 30], mask=[1, 0, 0])
-        #
+
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
             rdata['num'] = val
@@ -201,7 +201,7 @@ class TestMRecords(TestCase):
 
     def test_set_mask_fromfields(self):
         mbase = self.base.copy().view(mrecarray)
-        #
+
         nmask = np.array(
             [(0, 1, 0), (0, 1, 0), (1, 0, 1), (1, 0, 1), (0, 0, 0)],
             dtype=[('a', bool), ('b', bool), ('c', bool)])
@@ -237,7 +237,7 @@ class TestMRecords(TestCase):
         assert_equal(mbase.c._data,
                      asbytes_nested(['5', '5', 'three', 'four', 'five']))
         assert_equal(mbase.b._mask, [0, 0, 0, 0, 1])
-        #
+
         mbase = base.view(mrecarray).copy()
         mbase[:2] = masked
         assert_equal(mbase.a._data, [1, 2, 3, 4, 5])
@@ -328,7 +328,7 @@ class TestMRecords(TestCase):
         ddtype = [('a', int), ('b', float), ('c', '|S8')]
         mrec = fromarrays([_a, _b, _c], dtype=ddtype,
                           fill_value=(99999, 99999., 'N/A'))
-        #
+
         assert_equal(mrec.tolist(),
                      [(1, 1.1, None), (2, 2.2, asbytes('two')),
                       (None, None, asbytes('three'))])
@@ -344,12 +344,12 @@ class TestMRecords(TestCase):
         easy = mrecarray(1, dtype=[('i', int), ('s', '|S8'), ('f', float)])
         easy[0] = masked
         assert_equal(easy.filled(1).item(), (1, asbytes('1'), 1.))
-        #
+
         solo = mrecarray(1, dtype=[('f0', '<f8', (2, 2))])
         solo[0] = masked
         assert_equal(solo.filled(1).item(),
                      np.array((1,), dtype=solo.dtype).item())
-        #
+
         mult = mrecarray(2, dtype="i4, (2,3)float, float")
         mult[0] = masked
         mult[1] = (1, 1, 1)
@@ -360,7 +360,7 @@ class TestMRecords(TestCase):
 
 
 class TestView(TestCase):
-    #
+
     def setUp(self):
         (a, b) = (np.arange(10), np.random.rand(10))
         ndtype = [('a', np.float), ('b', np.float)]
@@ -396,7 +396,7 @@ class TestView(TestCase):
         self.assertTrue(test._fill_value is None)
 
 
-###############################################################################
+##############################################################################
 class TestMRecordsImport(TestCase):
     # Base test class for MaskedArrays.
     def __init__(self, *args, **kwds):
@@ -442,12 +442,12 @@ class TestMRecordsImport(TestCase):
         assert_equal(_mrec.dtype, mrec.dtype)
         for field in _mrec.dtype.names:
             assert_equal(getattr(_mrec, field), getattr(mrec._data, field))
-        #
+
         _mrec = fromrecords(nrec.tolist(), names='c1,c2,c3')
         assert_equal(_mrec.dtype, [('c1', int), ('c2', float), ('c3', '|S5')])
         for (f, n) in zip(('c1', 'c2', 'c3'), ('a', 'b', 'c')):
             assert_equal(getattr(_mrec, f), getattr(mrec._data, n))
-        #
+
         _mrec = fromrecords(mrec)
         assert_equal(_mrec.dtype, mrec.dtype)
         assert_equal_records(_mrec._data, mrec.filled())
@@ -456,19 +456,19 @@ class TestMRecordsImport(TestCase):
     def test_fromrecords_wmask(self):
         # Tests construction from records w/ mask.
         (mrec, nrec, ddtype) = self.data
-        #
+
         _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[0, 1, 0,])
         assert_equal_records(_mrec._data, mrec._data)
         assert_equal(_mrec._mask.tolist(), [(0, 0, 0), (1, 1, 1), (0, 0, 0)])
-        #
+
         _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=True)
         assert_equal_records(_mrec._data, mrec._data)
         assert_equal(_mrec._mask.tolist(), [(1, 1, 1), (1, 1, 1), (1, 1, 1)])
-        #
+
         _mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=mrec._mask)
         assert_equal_records(_mrec._data, mrec._data)
         assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
-        #
+
         _mrec = fromrecords(nrec.tolist(), dtype=ddtype,
                             mask=mrec._mask.tolist())
         assert_equal_records(_mrec._data, mrec._data)
@@ -476,7 +476,8 @@ class TestMRecordsImport(TestCase):
 
     def test_fromtextfile(self):
         # Tests reading from a text file.
-        fcontent = asbytes("""#
+        fcontent = asbytes(
+"""#
 'One (S)','Two (I)','Three (F)','Four (M)','Five (-)','Six (C)'
 'strings',1,1.0,'mixed column',,1
 'with embedded "double quotes"',2,2.0,1.0,,1
@@ -490,7 +491,7 @@ class TestMRecordsImport(TestCase):
         os.close(tmp_fd)
         mrectxt = fromtextfile(tmp_fl, delimitor=',', varnames='ABCDEFG')
         os.remove(tmp_fl)
-        #
+
         self.assertTrue(isinstance(mrectxt, MaskedRecords))
         assert_equal(mrectxt.F, [1, 1, 1, 1])
         assert_equal(mrectxt.E._mask, [1, 1, 1, 1])
@@ -515,7 +516,5 @@ def test_record_array_with_object_field():
     y[1]
 
 
-###############################################################################
-#------------------------------------------------------------------------------
 if __name__ == "__main__":
     run_module_suite()
diff --git a/numpy/ma/tests/test_old_ma.py b/numpy/ma/tests/test_old_ma.py
index 047f91c77..a32f358c0 100644
--- a/numpy/ma/tests/test_old_ma.py
+++ b/numpy/ma/tests/test_old_ma.py
@@ -1,13 +1,25 @@
 from __future__ import division, absolute_import, print_function
 
-import sys
 from functools import reduce
 
 import numpy as np
-from numpy.ma import *
-from numpy.core.numerictypes import float32
-from numpy.ma.core import umath
-from numpy.testing import *
+import numpy.core.umath as umath
+import numpy.core.fromnumeric as fromnumeric
+from numpy.testing import TestCase, run_module_suite, assert_
+from numpy.ma.testutils import assert_array_equal
+from numpy.ma import (
+    MaskType, MaskedArray, absolute, add, all, allclose, allequal, alltrue,
+    arange, arccos, arcsin, arctan, arctan2, array, average, choose,
+    concatenate, conjugate, cos, cosh, count, divide, equal, exp, filled,
+    getmask, greater, greater_equal, inner, isMaskedArray, less,
+    less_equal, log, log10, make_mask, masked, masked_array, masked_equal,
+    masked_greater, masked_greater_equal, masked_inside, masked_less,
+    masked_less_equal, masked_not_equal, masked_outside,
+    masked_print_option, masked_values, masked_where, maximum, minimum,
+    multiply, nomask, nonzero, not_equal, ones, outer, product, put, ravel,
+    repeat, resize, shape, sin, sinh, sometrue, sort, sqrt, subtract, sum,
+    take, tan, tanh, transpose, where, zeros,
+    )
 
 pi = np.pi
 
@@ -15,10 +27,7 @@ pi = np.pi
 def eq(v, w, msg=''):
     result = allclose(v, w)
     if not result:
-        print("""Not eq:%s
-%s
-----
-%s""" % (msg, str(v), str(w)))
+        print("Not eq:%s\n%s\n----%s" % (msg, str(v), str(w)))
     return result
 
 
@@ -202,10 +211,11 @@ class TestMa(TestCase):
         x2 = array(x1, mask=[1, 0, 0, 0])
         x3 = array(x1, mask=[0, 1, 0, 1])
         x4 = array(x1)
-    # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
+        # test conversion to strings
+        str(x2)  # raises?
+        repr(x2)  # raises?
         assert_(eq(np.sort(x1), sort(x2, fill_value=0)))
-    # tests of indexing
+        # tests of indexing
         assert_(type(x2[1]) is type(x1[1]))
         assert_(x1[1] == x2[1])
         assert_(x2[0] is masked)
@@ -387,7 +397,7 @@ class TestMa(TestCase):
                    [1, 0, 1, 0, 1]))
         assert_(eq(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
                    [99, 99, 3, 4, 5]))
-        atest = ones((10, 10, 10), dtype=float32)
+        atest = ones((10, 10, 10), dtype=np.float32)
         btest = zeros(atest.shape, MaskType)
         ctest = masked_where(btest, atest)
         assert_(eq(atest, ctest))
@@ -489,7 +499,7 @@ class TestMa(TestCase):
         xm /= arange(10)
         assert_(eq(xm, ones((10,))))
 
-        x = arange(10).astype(float32)
+        x = arange(10).astype(np.float32)
         xm = arange(10)
         xm[2] = masked
         x += 1.
diff --git a/numpy/ma/tests/test_subclassing.py b/numpy/ma/tests/test_subclassing.py
index 2e98348e6..68734425c 100644
--- a/numpy/ma/tests/test_subclassing.py
+++ b/numpy/ma/tests/test_subclassing.py
@@ -8,15 +8,14 @@
 """
 from __future__ import division, absolute_import, print_function
 
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = '1.0'
-__revision__ = "$Revision: 3473 $"
-__date__ = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
-
 import numpy as np
-from numpy.testing import *
-from numpy.ma.testutils import *
-from numpy.ma.core import *
+from numpy.testing import TestCase, run_module_suite, assert_raises
+from numpy.ma.testutils import assert_equal
+from numpy.ma.core import (
+    array, arange, masked, MaskedArray, masked_array, log, add, hypot,
+    divide, asarray, asanyarray, nomask
+    )
+# from numpy.ma.core import (
 
 
 class SubArray(np.ndarray):
diff --git a/numpy/ma/testutils.py b/numpy/ma/testutils.py
index feff3e879..8dc821878 100644
--- a/numpy/ma/testutils.py
+++ b/numpy/ma/testutils.py
@@ -7,32 +7,48 @@
 """
 from __future__ import division, absolute_import, print_function
 
-__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
-__version__ = "1.0"
-__revision__ = "$Revision: 3529 $"
-__date__ = "$Date: 2007-11-13 10:01:14 +0200 (Tue, 13 Nov 2007) $"
-
-
 import operator
 
 import numpy as np
 from numpy import ndarray, float_
 import numpy.core.umath as umath
-from numpy.testing import *
+from numpy.testing import (
+    TestCase, assert_, assert_allclose, assert_array_almost_equal_nulp,
+    assert_raises, build_err_msg, run_module_suite,
+    )
 import numpy.testing.utils as utils
+from .core import mask_or, getmask, masked_array, nomask, masked, filled
+
+__all__masked = [
+    'almost', 'approx', 'assert_almost_equal', 'assert_array_almost_equal',
+    'assert_array_approx_equal', 'assert_array_compare',
+    'assert_array_equal', 'assert_array_less', 'assert_close',
+    'assert_equal', 'assert_equal_records', 'assert_mask_equal',
+    'assert_not_equal', 'fail_if_array_equal',
+    ]
+
+# Include some normal test functions to avoid breaking other projects who
+# have mistakenly included them from this file. SciPy is one. That is
+# unfortunate, as some of these functions are not intended to work with
+# masked arrays. But there was no way to tell before.
+__some__from_testing = [
+    'TestCase', 'assert_', 'assert_allclose',
+    'assert_array_almost_equal_nulp', 'assert_raises', 'run_module_suite',
+    ]
 
-from .core import mask_or, getmask, masked_array, nomask, masked, filled, \
-                 equal, less
+__all__ = __all__masked + __some__from_testing
+
+
+def approx(a, b, fill_value=True, rtol=1e-5, atol=1e-8):
+    """
+    Returns true if all components of a and b are equal to given tolerances.
 
-#------------------------------------------------------------------------------
-def approx (a, b, fill_value=True, rtol=1e-5, atol=1e-8):
-    """Returns true if all components of a and b are equal subject to given tolerances.
+    If fill_value is True, masked values considered equal. Otherwise,
+    masked values are considered unequal.  The relative error rtol should
+    be positive and << 1.0 The absolute error atol comes into play for
+    those elements of b that are very small or zero; it says how small a
+    must be also.
 
-If fill_value is True, masked values considered equal. Otherwise, masked values
-are considered unequal.
-The relative error rtol should be positive and << 1.0
-The absolute error atol comes into play for those elements of b that are very
-small or zero; it says how small a must be also.
     """
     m = mask_or(getmask(a), getmask(b))
     d1 = filled(a)
@@ -46,9 +62,12 @@ small or zero; it says how small a must be also.
 
 
 def almost(a, b, decimal=6, fill_value=True):
-    """Returns True if a and b are equal up to decimal places.
-If fill_value is True, masked values considered equal. Otherwise, masked values
-are considered unequal.
+    """
+    Returns True if a and b are equal up to decimal places.
+
+    If fill_value is True, masked values considered equal. Otherwise,
+    masked values are considered unequal.
+
     """
     m = mask_or(getmask(a), getmask(b))
     d1 = filled(a)
@@ -61,16 +80,24 @@ are considered unequal.
     return d.ravel()
 
 
-#................................................
 def _assert_equal_on_sequences(actual, desired, err_msg=''):
-    "Asserts the equality of two non-array sequences."
+    """
+    Asserts the equality of two non-array sequences.
+
+    """
     assert_equal(len(actual), len(desired), err_msg)
     for k in range(len(desired)):
         assert_equal(actual[k], desired[k], 'item=%r\n%s' % (k, err_msg))
     return
 
+
 def assert_equal_records(a, b):
-    """Asserts that two records are equal. Pretty crude for now."""
+    """
+    Asserts that two records are equal.
+
+    Pretty crude for now.
+
+    """
     assert_equal(a.dtype, b.dtype)
     for f in a.dtype.names:
         (af, bf) = (operator.getitem(a, f), operator.getitem(b, f))
@@ -80,14 +107,17 @@ def assert_equal_records(a, b):
 
 
 def assert_equal(actual, desired, err_msg=''):
-    "Asserts that two items are equal."
+    """
+    Asserts that two items are equal.
+
+    """
     # Case #1: dictionary .....
     if isinstance(desired, dict):
         if not isinstance(actual, dict):
             raise AssertionError(repr(type(actual)))
         assert_equal(len(actual), len(desired), err_msg)
         for k, i in desired.items():
-            if not k in actual:
+            if k not in actual:
                 raise AssertionError("%s not in %s" % (k, actual))
             assert_equal(actual[k], desired[k], 'key=%r\n%s' % (k, err_msg))
         return
@@ -101,7 +131,7 @@ def assert_equal(actual, desired, err_msg=''):
         return
     # Case #4. arrays or equivalent
     if ((actual is masked) and not (desired is masked)) or \
-        ((desired is masked) and not (actual is masked)):
+            ((desired is masked) and not (actual is masked)):
         msg = build_err_msg([actual, desired],
                             err_msg, header='', names=('x', 'y'))
         raise ValueError(msg)
@@ -112,26 +142,20 @@ def assert_equal(actual, desired, err_msg=''):
         return _assert_equal_on_sequences(actual.tolist(),
                                           desired.tolist(),
                                           err_msg='')
-#    elif actual_dtype.char in "OV" and desired_dtype.char in "OV":
-#        if (actual_dtype != desired_dtype) and actual_dtype:
-#            msg = build_err_msg([actual_dtype, desired_dtype],
-#                                err_msg, header='', names=('actual', 'desired'))
-#            raise ValueError(msg)
-#        return _assert_equal_on_sequences(actual.tolist(),
-#                                          desired.tolist(),
-#                                          err_msg='')
     return assert_array_equal(actual, desired, err_msg)
 
 
 def fail_if_equal(actual, desired, err_msg='',):
-    """Raises an assertion error if two items are equal.
+    """
+    Raises an assertion error if two items are equal.
+
     """
     if isinstance(desired, dict):
         if not isinstance(actual, dict):
             raise AssertionError(repr(type(actual)))
         fail_if_equal(len(actual), len(desired), err_msg)
         for k, i in desired.items():
-            if not k in actual:
+            if k not in actual:
                 raise AssertionError(repr(k))
             fail_if_equal(actual[k], desired[k], 'key=%r\n%s' % (k, err_msg))
         return
@@ -146,12 +170,16 @@ def fail_if_equal(actual, desired, err_msg='',):
     if not desired != actual:
         raise AssertionError(msg)
 
+
 assert_not_equal = fail_if_equal
 
 
 def assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True):
-    """Asserts that two items are almost equal.
-    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal)
+    """
+    Asserts that two items are almost equal.
+
+    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal).
+
     """
     if isinstance(actual, np.ndarray) or isinstance(desired, np.ndarray):
         return assert_array_almost_equal(actual, desired, decimal=decimal,
@@ -167,17 +195,18 @@ assert_close = assert_almost_equal
 
 def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
                          fill_value=True):
-    """Asserts that a comparison relation between two masked arrays is satisfied
-    elementwise."""
-    # Fill the data first
-#    xf = filled(x)
-#    yf = filled(y)
+    """
+    Asserts that comparison between two masked arrays is satisfied.
+
+    The comparison is elementwise.
+
+    """
     # Allocate a common mask and refill
     m = mask_or(getmask(x), getmask(y))
     x = masked_array(x, copy=False, mask=m, keep_mask=False, subok=False)
     y = masked_array(y, copy=False, mask=m, keep_mask=False, subok=False)
     if ((x is masked) and not (y is masked)) or \
-        ((y is masked) and not (x is masked)):
+            ((y is masked) and not (x is masked)):
         msg = build_err_msg([x, y], err_msg=err_msg, verbose=verbose,
                             header=header, names=('x', 'y'))
         raise ValueError(msg)
@@ -190,14 +219,20 @@ def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
 
 
 def assert_array_equal(x, y, err_msg='', verbose=True):
-    """Checks the elementwise equality of two masked arrays."""
+    """
+    Checks the elementwise equality of two masked arrays.
+
+    """
     assert_array_compare(operator.__eq__, x, y,
                          err_msg=err_msg, verbose=verbose,
                          header='Arrays are not equal')
 
 
 def fail_if_array_equal(x, y, err_msg='', verbose=True):
-    "Raises an assertion error if two masked arrays are not equal (elementwise)."
+    """
+    Raises an assertion error if two masked arrays are not equal elementwise.
+
+    """
     def compare(x, y):
         return (not np.alltrue(approx(x, y)))
     assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
@@ -205,8 +240,12 @@ def fail_if_array_equal(x, y, err_msg='', verbose=True):
 
 
 def assert_array_approx_equal(x, y, decimal=6, err_msg='', verbose=True):
-    """Checks the elementwise equality of two masked arrays, up to a given
-    number of decimals."""
+    """
+    Checks the equality of two masked arrays, up to given number odecimals.
+
+    The equality is checked elementwise.
+
+    """
     def compare(x, y):
         "Returns the result of the loose comparison between x and y)."
         return approx(x, y, rtol=10. ** -decimal)
@@ -215,8 +254,12 @@ def assert_array_approx_equal(x, y, decimal=6, err_msg='', verbose=True):
 
 
 def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
-    """Checks the elementwise equality of two masked arrays, up to a given
-    number of decimals."""
+    """
+    Checks the equality of two masked arrays, up to given number odecimals.
+
+    The equality is checked elementwise.
+
+    """
     def compare(x, y):
         "Returns the result of the loose comparison between x and y)."
         return almost(x, y, decimal)
@@ -225,14 +268,20 @@ def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
 
 
 def assert_array_less(x, y, err_msg='', verbose=True):
-    "Checks that x is smaller than y elementwise."
+    """
+    Checks that x is smaller than y elementwise.
+
+    """
     assert_array_compare(operator.__lt__, x, y,
                          err_msg=err_msg, verbose=verbose,
                          header='Arrays are not less-ordered')
 
 
 def assert_mask_equal(m1, m2, err_msg=''):
-    """Asserts the equality of two masks."""
+    """
+    Asserts the equality of two masks.
+
+    """
     if m1 is nomask:
         assert_(m2 is nomask)
     if m2 is nomask:
diff --git a/numpy/ma/timer_comparison.py b/numpy/ma/timer_comparison.py
index b1c056cfc..d03080f47 100644
--- a/numpy/ma/timer_comparison.py
+++ b/numpy/ma/timer_comparison.py
@@ -15,13 +15,12 @@ np.seterr(all='ignore')
 pi = np.pi
 
 
-class moduletester(object):
+class ModuleTester(object):
     def __init__(self, module):
         self.module = module
         self.allequal = module.allequal
         self.arange = module.arange
         self.array = module.array
-#        self.average =  module.average
         self.concatenate = module.concatenate
         self.count = module.count
         self.equal = module.equal
@@ -53,8 +52,10 @@ class moduletester(object):
 
     def assert_array_compare(self, comparison, x, y, err_msg='', header='',
                          fill_value=True):
-        """Asserts that a comparison relation between two masked arrays is satisfied
-        elementwise."""
+        """
+        Assert that a comparison of two masked arrays is satisfied elementwise.
+
+        """
         xf = self.filled(x)
         yf = self.filled(y)
         m = self.mask_or(self.getmask(x), self.getmask(y))
@@ -74,7 +75,7 @@ class moduletester(object):
             elif np.isnan(y):
                 y = 0
         try:
-            cond = (x.shape==() or y.shape==()) or x.shape == y.shape
+            cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
             if not cond:
                 msg = build_err_msg([x, y],
                                     err_msg
@@ -106,33 +107,38 @@ class moduletester(object):
             raise ValueError(msg)
 
     def assert_array_equal(self, x, y, err_msg=''):
-        """Checks the elementwise equality of two masked arrays."""
+        """
+        Checks the elementwise equality of two masked arrays.
+
+        """
         self.assert_array_compare(self.equal, x, y, err_msg=err_msg,
                                   header='Arrays are not equal')
 
     def test_0(self):
-        "Tests creation"
+        """
+        Tests creation
+
+        """
         x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
         xm = self.masked_array(x, mask=m)
         xm[0]
 
     def test_1(self):
-        "Tests creation"
+        """
+        Tests creation
+
+        """
         x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
         y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
-        a10 = 10.
         m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
         m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
         xm = self.masked_array(x, mask=m1)
         ym = self.masked_array(y, mask=m2)
-        z = np.array([-.5, 0., .5, .8])
-        zm = self.masked_array(z, mask=[0, 1, 0, 0])
         xf = np.where(m1, 1.e+20, x)
         xm.set_fill_value(1.e+20)
 
         assert((xm-ym).filled(0).any())
-        #fail_if_equal(xm.mask.astype(int_), ym.mask.astype(int_))
         s = x.shape
         assert(xm.size == reduce(lambda x, y:x*y, s))
         assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
@@ -143,51 +149,41 @@ class moduletester(object):
             xm.shape = s
             ym.shape = s
             xf.shape = s
-
             assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
 
     def test_2(self):
-        "Tests conversions and indexing"
+        """
+        Tests conversions and indexing.
+
+        """
         x1 = np.array([1, 2, 4, 3])
         x2 = self.array(x1, mask=[1, 0, 0, 0])
         x3 = self.array(x1, mask=[0, 1, 0, 1])
         x4 = self.array(x1)
-    # test conversion to strings
-        junk, garbage = str(x2), repr(x2)
-#        assert_equal(np.sort(x1), self.sort(x2, fill_value=0))
-    # tests of indexing
+        # test conversion to strings, no errors
+        str(x2)
+        repr(x2)
+        # tests of indexing
         assert type(x2[1]) is type(x1[1])
         assert x1[1] == x2[1]
-#        assert self.allequal(x1[2],x2[2])
-#        assert self.allequal(x1[2:5],x2[2:5])
-#        assert self.allequal(x1[:],x2[:])
-#        assert self.allequal(x1[1:], x3[1:])
         x1[2] = 9
         x2[2] = 9
         self.assert_array_equal(x1, x2)
         x1[1:3] = 99
         x2[1:3] = 99
-#        assert self.allequal(x1,x2)
         x2[1] = self.masked
-#        assert self.allequal(x1,x2)
         x2[1:3] = self.masked
-#        assert self.allequal(x1,x2)
         x2[:] = x1
         x2[1] = self.masked
-#        assert self.allequal(self.getmask(x2),self.array([0,1,0,0]))
         x3[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
-#        assert self.allequal(self.getmask(x3), self.array([0,1,1,0]))
         x4[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
-#        assert self.allequal(self.getmask(x4), self.array([0,1,1,0]))
-#        assert self.allequal(x4, self.array([1,2,3,4]))
         x1 = np.arange(5)*1.0
         x2 = self.masked_values(x1, 3.0)
-#        assert self.allequal(x1,x2)
-#        assert self.allequal(self.array([0,0,0,1,0], self.MaskType), x2.mask)
         x1 = self.array([1, 'hello', 2, 3], object)
         x2 = np.array([1, 'hello', 2, 3], object)
-        s1 = x1[1]
-        s2 = x2[1]
+        # check that no error occurs.
+        x1[1]
+        x2[1]
         assert x1[1:1].shape == (0,)
         # Tests copy-size
         n = [0, 0, 1, 0, 0]
@@ -197,9 +193,11 @@ class moduletester(object):
         m3 = self.make_mask(m, copy=1)
         assert(m is not m3)
 
-
     def test_3(self):
-        "Tests resize/repeat"
+        """
+        Tests resize/repeat
+
+        """
         x4 = self.arange(4)
         x4[2] = self.masked
         y4 = self.resize(x4, (8,))
@@ -214,9 +212,11 @@ class moduletester(object):
         y8 = x4.repeat(2, 0)
         assert self.allequal(y5, y8)
 
-    #----------------------------------
     def test_4(self):
-        "Test of take, transpose, inner, outer products"
+        """
+        Test of take, transpose, inner, outer products.
+
+        """
         x = self.arange(24)
         y = np.arange(24)
         x[5:6] = self.masked
@@ -234,10 +234,12 @@ class moduletester(object):
         assert t[0] == 'abc'
         assert t[1] == 2
         assert t[2] == 3
-    #----------------------------------
+
     def test_5(self):
-        "Tests inplace w/ scalar"
+        """
+        Tests inplace w/ scalar
 
+        """
         x = self.arange(10)
         y = self.arange(10)
         xm = self.arange(10)
@@ -282,15 +284,14 @@ class moduletester(object):
         x = self.arange(10).astype(float_)
         xm = self.arange(10)
         xm[2] = self.masked
-        id1 = self.id(x.raw_data())
         x += 1.
-        #assert id1 == self.id(x.raw_data())
-        assert self.allequal(x, y+1.)
-
+        assert self.allequal(x, y + 1.)
 
     def test_6(self):
-        "Tests inplace w/ array"
+        """
+        Tests inplace w/ array
 
+        """
         x = self.arange(10, dtype=float_)
         y = self.arange(10)
         xm = self.arange(10, dtype=float_)
@@ -337,7 +338,6 @@ class moduletester(object):
         x /= a
         xm /= a
 
-    #----------------------------------
     def test_7(self):
         "Tests ufunc"
         d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0, 1]+[0]*6),
@@ -361,7 +361,6 @@ class moduletester(object):
 #                  'less', 'greater',
 #                  'logical_and', 'logical_or', 'logical_xor',
                   ]:
-            #print f
             try:
                 uf = getattr(self.umath, f)
             except AttributeError:
@@ -373,7 +372,6 @@ class moduletester(object):
             self.assert_array_equal(ur.filled(0), mr.filled(0), f)
             self.assert_array_equal(ur._mask, mr._mask)
 
-    #----------------------------------
     def test_99(self):
         # test average
         ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
@@ -411,7 +409,6 @@ class moduletester(object):
         m5 = [0, 1, 1, 1, 1, 1]
         self.assert_array_equal(self.average(self.masked_array(x, m1), axis=0), 2.5)
         self.assert_array_equal(self.average(self.masked_array(x, m2), axis=0), 2.5)
-    #    assert(self.average(masked_array(x, m4),axis=0) is masked)
         self.assert_array_equal(self.average(self.masked_array(x, m5), axis=0), 0.0)
         self.assert_array_equal(self.count(self.average(self.masked_array(x, m4), axis=0)), 0)
         z = self.masked_array(y, m3)
@@ -419,41 +416,25 @@ class moduletester(object):
         self.assert_array_equal(self.average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])
         self.assert_array_equal(self.average(z, axis=1), [2.5, 5.0])
         self.assert_array_equal(self.average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])
-    #------------------------
+
     def test_A(self):
         x = self.arange(24)
-        y = np.arange(24)
         x[5:6] = self.masked
         x = x.reshape(2, 3, 4)
 
 
-################################################################################
 if __name__ == '__main__':
-
-    setup_base = "from __main__ import moduletester \n"\
-                 "import numpy\n" \
-                 "tester = moduletester(module)\n"
-#    setup_new = "import np.ma.core_ini as module\n"+setup_base
-    setup_cur = "import np.ma.core as module\n"+setup_base
-#    setup_alt = "import np.ma.core_alt as module\n"+setup_base
-#    setup_tmp = "import np.ma.core_tmp as module\n"+setup_base
-
+    setup_base = ("from __main__ import ModuleTester \n"
+                  "import numpy\n"
+                  "tester = ModuleTester(module)\n")
+    setup_cur = "import np.ma.core as module\n" + setup_base
     (nrepeat, nloop) = (10, 10)
 
     if 1:
         for i in range(1, 8):
             func = 'tester.test_%i()' % i
-#            new = timeit.Timer(func, setup_new).repeat(nrepeat, nloop*10)
             cur = timeit.Timer(func, setup_cur).repeat(nrepeat, nloop*10)
-#            alt = timeit.Timer(func, setup_alt).repeat(nrepeat, nloop*10)
-#            tmp = timeit.Timer(func, setup_tmp).repeat(nrepeat, nloop*10)
-#            new = np.sort(new)
             cur = np.sort(cur)
-#            alt = np.sort(alt)
-#            tmp = np.sort(tmp)
-            print("#%i" % i +50*'.')
-            print(eval("moduletester.test_%i.__doc__" % i))
-#            print "core_ini     : %.3f - %.3f" % (new[0], new[1])
+            print("#%i" % i + 50*'.')
+            print(eval("ModuleTester.test_%i.__doc__" % i))
             print("core_current : %.3f - %.3f" % (cur[0], cur[1]))
-#            print "core_alt     : %.3f - %.3f" % (alt[0], alt[1])
-#            print "core_tmp     : %.3f - %.3f" % (tmp[0], tmp[1])