STY: Giant comma spacing fixup.

Run the 2to3 ws_comma fixer on *.py files. Some lines are now too long
and will need to be broken at some point. OTOH, some lines were already
too long and need to be broken at some point. Now seems as good a time
as any to do this with open PRs at a minimum.

1 files changed, 70 insertions, 70 deletions

diff --git a/numpy/ma/timer_comparison.py b/numpy/ma/timer_comparison.py
index 350412b85..b1c056cfc 100644
--- a/numpy/ma/timer_comparison.py
+++ b/numpy/ma/timer_comparison.py
@@ -83,7 +83,7 @@ class moduletester(object):
                                     header=header,
                                     names=('x', 'y'))
                 assert cond, msg
-            val = comparison(x,y)
+            val = comparison(x, y)
             if m is not self.nomask and fill_value:
                 val = self.masked_array(val, mask=m)
             if isinstance(val, bool):
@@ -112,45 +112,45 @@ class moduletester(object):
 
     def test_0(self):
         "Tests creation"
-        x = np.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        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"
-        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.])
+        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]
+        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])
+        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))
+        assert(xm.size == reduce(lambda x, y:x*y, s))
+        assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
 
-        for s in [(4,3), (6,2)]:
+        for s in [(4, 3), (6, 2)]:
             x.shape = s
             y.shape = s
             xm.shape = s
             ym.shape = s
             xf.shape = s
 
-            assert(self.count(xm) == len(m1) - reduce(lambda x,y:x+y, m1))
+            assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
 
     def test_2(self):
         "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])
+        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)
@@ -164,7 +164,7 @@ class moduletester(object):
 #        assert self.allequal(x1[1:], x3[1:])
         x1[2] = 9
         x2[2] = 9
-        self.assert_array_equal(x1,x2)
+        self.assert_array_equal(x1, x2)
         x1[1:3] = 99
         x2[1:3] = 99
 #        assert self.allequal(x1,x2)
@@ -175,22 +175,22 @@ class moduletester(object):
         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])
+        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])
+        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)
+        x1 = self.array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
         s1 = x1[1]
         s2 = x2[1]
         assert x1[1:1].shape == (0,)
         # Tests copy-size
-        n = [0,0,1,0,0]
+        n = [0, 0, 1, 0, 0]
         m = self.make_mask(n)
         m2 = self.make_mask(m)
         assert(m is m2)
@@ -203,16 +203,16 @@ class moduletester(object):
         x4 = self.arange(4)
         x4[2] = self.masked
         y4 = self.resize(x4, (8,))
-        assert self.allequal(self.concatenate([x4,x4]), y4)
-        assert self.allequal(self.getmask(y4),[0,0,1,0,0,0,1,0])
-        y5 = self.repeat(x4, (2,2,2,2), axis=0)
-        self.assert_array_equal(y5, [0,0,1,1,2,2,3,3])
+        assert self.allequal(self.concatenate([x4, x4]), y4)
+        assert self.allequal(self.getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])
+        y5 = self.repeat(x4, (2, 2, 2, 2), axis=0)
+        self.assert_array_equal(y5, [0, 0, 1, 1, 2, 2, 3, 3])
         y6 = self.repeat(x4, 2, axis=0)
         assert self.allequal(y5, y6)
-        y7 = x4.repeat((2,2,2,2), axis=0)
-        assert self.allequal(y5,y7)
-        y8 = x4.repeat(2,0)
-        assert self.allequal(y5,y8)
+        y7 = x4.repeat((2, 2, 2, 2), axis=0)
+        assert self.allequal(y5, y7)
+        y8 = x4.repeat(2, 0)
+        assert self.allequal(y5, y8)
 
     #----------------------------------
     def test_4(self):
@@ -220,17 +220,17 @@ class moduletester(object):
         x = self.arange(24)
         y = np.arange(24)
         x[5:6] = self.masked
-        x = x.reshape(2,3,4)
-        y = y.reshape(2,3,4)
-        assert self.allequal(np.transpose(y,(2,0,1)), self.transpose(x,(2,0,1)))
-        assert self.allequal(np.take(y, (2,0,1), 1), self.take(x, (2,0,1), 1))
-        assert self.allequal(np.inner(self.filled(x,0), self.filled(y,0)),
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert self.allequal(np.transpose(y, (2, 0, 1)), self.transpose(x, (2, 0, 1)))
+        assert self.allequal(np.take(y, (2, 0, 1), 1), self.take(x, (2, 0, 1), 1))
+        assert self.allequal(np.inner(self.filled(x, 0), self.filled(y, 0)),
                             self.inner(x, y))
-        assert self.allequal(np.outer(self.filled(x,0), self.filled(y,0)),
+        assert self.allequal(np.outer(self.filled(x, 0), self.filled(y, 0)),
                             self.outer(x, y))
         y = self.array(['abc', 1, 'def', 2, 3], object)
         y[2] = self.masked
-        t = self.take(y,[0,3,4])
+        t = self.take(y, [0, 3, 4])
         assert t[0] == 'abc'
         assert t[1] == 2
         assert t[2] == 3
@@ -300,9 +300,9 @@ class moduletester(object):
         a[-1] = self.masked
         x += a
         xm += a
-        assert self.allequal(x,y+a)
-        assert self.allequal(xm,y+a)
-        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
+        assert self.allequal(x, y+a)
+        assert self.allequal(xm, y+a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
 
         x = self.arange(10, dtype=float_)
         xm = self.arange(10, dtype=float_)
@@ -312,9 +312,9 @@ class moduletester(object):
         a[-1] = self.masked
         x -= a
         xm -= a
-        assert self.allequal(x,y-a)
-        assert self.allequal(xm,y-a)
-        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
+        assert self.allequal(x, y-a)
+        assert self.allequal(xm, y-a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
 
         x = self.arange(10, dtype=float_)
         xm = self.arange(10, dtype=float_)
@@ -324,9 +324,9 @@ class moduletester(object):
         a[-1] = self.masked
         x *= a
         xm *= a
-        assert self.allequal(x,y*a)
-        assert self.allequal(xm,y*a)
-        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
+        assert self.allequal(x, y*a)
+        assert self.allequal(xm, y*a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
 
         x = self.arange(10, dtype=float_)
         xm = self.arange(10, dtype=float_)
@@ -340,8 +340,8 @@ class moduletester(object):
     #----------------------------------
     def test_7(self):
         "Tests ufunc"
-        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
-             self.array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
+        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0, 1]+[0]*6),
+             self.array([1.0, 0, -1, pi/2]*2, mask=[1, 0]+[0]*6),)
         for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
 #                  'sin', 'cos', 'tan',
 #                  'arcsin', 'arccos', 'arctan',
@@ -376,55 +376,55 @@ class moduletester(object):
     #----------------------------------
     def test_99(self):
         # test average
-        ott = self.array([0.,1.,2.,3.], mask=[1,0,0,0])
-        self.assert_array_equal(2.0, self.average(ott,axis=0))
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        self.assert_array_equal(2.0, self.average(ott, axis=0))
         self.assert_array_equal(2.0, self.average(ott, weights=[1., 1., 2., 1.]))
-        result, wts = self.average(ott, weights=[1.,1.,2.,1.], returned=1)
+        result, wts = self.average(ott, weights=[1., 1., 2., 1.], returned=1)
         self.assert_array_equal(2.0, result)
         assert(wts == 4.0)
         ott[:] = self.masked
-        assert(self.average(ott,axis=0) is self.masked)
-        ott = self.array([0.,1.,2.,3.], mask=[1,0,0,0])
-        ott = ott.reshape(2,2)
-        ott[:,1] = self.masked
-        self.assert_array_equal(self.average(ott,axis=0), [2.0, 0.0])
-        assert(self.average(ott,axis=1)[0] is self.masked)
-        self.assert_array_equal([2.,0.], self.average(ott, axis=0))
+        assert(self.average(ott, axis=0) is self.masked)
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = self.masked
+        self.assert_array_equal(self.average(ott, axis=0), [2.0, 0.0])
+        assert(self.average(ott, axis=1)[0] is self.masked)
+        self.assert_array_equal([2., 0.], self.average(ott, axis=0))
         result, wts = self.average(ott, axis=0, returned=1)
         self.assert_array_equal(wts, [1., 0.])
-        w1 = [0,1,1,1,1,0]
-        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
         x = self.arange(6)
         self.assert_array_equal(self.average(x, axis=0), 2.5)
         self.assert_array_equal(self.average(x, axis=0, weights=w1), 2.5)
         y = self.array([self.arange(6), 2.0*self.arange(6)])
         self.assert_array_equal(self.average(y, None), np.add.reduce(np.arange(6))*3./12.)
         self.assert_array_equal(self.average(y, axis=0), np.arange(6) * 3./2.)
-        self.assert_array_equal(self.average(y, axis=1), [self.average(x,axis=0), self.average(x,axis=0) * 2.0])
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
         self.assert_array_equal(self.average(y, None, weights=w2), 20./6.)
-        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.])
-        self.assert_array_equal(self.average(y, axis=1), [self.average(x,axis=0), self.average(x,axis=0) * 2.0])
+        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.])
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
         m1 = self.zeros(6)
-        m2 = [0,0,1,1,0,0]
-        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
         m4 = self.ones(6)
         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)
+        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)
+        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)
         self.assert_array_equal(self.average(z, None), 20./6.)
-        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=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])
+        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)
+        x = x.reshape(2, 3, 4)
 
 
 ################################################################################
@@ -441,7 +441,7 @@ if __name__ == '__main__':
     (nrepeat, nloop) = (10, 10)
 
     if 1:
-        for i in range(1,8):
+        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)