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.

5 files changed, 137 insertions, 137 deletions

diff --git a/numpy/matrixlib/defmatrix.py b/numpy/matrixlib/defmatrix.py
index 1ca835af2..0a73725c2 100644
--- a/numpy/matrixlib/defmatrix.py
+++ b/numpy/matrixlib/defmatrix.py
@@ -39,7 +39,7 @@ else:
     del k
 
     def _eval(astr):
-        str_ = astr.translate(_table,_todelete)
+        str_ = astr.translate(_table, _todelete)
         if not str_:
             raise TypeError("Invalid data string supplied: " + astr)
         else:
@@ -95,7 +95,7 @@ def asmatrix(data, dtype=None):
     """
     return matrix(data, dtype=dtype, copy=False)
 
-def matrix_power(M,n):
+def matrix_power(M, n):
     """
     Raise a square matrix to the (integer) power `n`.
 
@@ -169,7 +169,7 @@ def matrix_power(M,n):
     M = asanyarray(M)
     if len(M.shape) != 2 or M.shape[0] != M.shape[1]:
         raise ValueError("input must be a square array")
-    if not issubdtype(type(n),int):
+    if not issubdtype(type(n), int):
         raise TypeError("exponent must be an integer")
 
     from numpy.linalg import inv
@@ -185,21 +185,21 @@ def matrix_power(M,n):
     result = M
     if n <= 3:
         for _ in range(n-1):
-            result=N.dot(result,M)
+            result=N.dot(result, M)
         return result
 
     # binary decomposition to reduce the number of Matrix
     # multiplications for n > 3.
     beta = binary_repr(n)
-    Z,q,t = M,0,len(beta)
+    Z, q, t = M, 0, len(beta)
     while beta[t-q-1] == '0':
-        Z = N.dot(Z,Z)
+        Z = N.dot(Z, Z)
         q += 1
     result = Z
-    for k in range(q+1,t):
-        Z = N.dot(Z,Z)
+    for k in range(q+1, t):
+        Z = N.dot(Z, Z)
         if beta[t-k-1] == '1':
-            result = N.dot(result,Z)
+            result = N.dot(result, Z)
     return result
 
 
@@ -271,9 +271,9 @@ class matrix(N.ndarray):
         if (ndim > 2):
             raise ValueError("matrix must be 2-dimensional")
         elif ndim == 0:
-            shape = (1,1)
+            shape = (1, 1)
         elif ndim == 1:
-            shape = (1,shape[0])
+            shape = (1, shape[0])
 
         order = False
         if (ndim == 2) and arr.flags.fortran:
@@ -304,9 +304,9 @@ class matrix(N.ndarray):
         else:
             newshape = self.shape
         if ndim == 0:
-            self.shape = (1,1)
+            self.shape = (1, 1)
         elif ndim == 1:
-            self.shape = (1,newshape[0])
+            self.shape = (1, newshape[0])
         return
 
     def __getitem__(self, index):
@@ -330,13 +330,13 @@ class matrix(N.ndarray):
             except:
                 n = 0
             if n > 1 and isscalar(index[1]):
-                out.shape = (sh,1)
+                out.shape = (sh, 1)
             else:
-                out.shape = (1,sh)
+                out.shape = (1, sh)
         return out
 
     def __mul__(self, other):
-        if isinstance(other,(N.ndarray, list, tuple)) :
+        if isinstance(other, (N.ndarray, list, tuple)) :
             # This promotes 1-D vectors to row vectors
             return N.dot(self, asmatrix(other))
         if isscalar(other) or not hasattr(other, '__rmul__') :
@@ -378,7 +378,7 @@ class matrix(N.ndarray):
         orientation.
         """
         if axis is None:
-            return self[0,0]
+            return self[0, 0]
         elif axis==0:
             return self
         elif axis==1:
@@ -391,7 +391,7 @@ class matrix(N.ndarray):
         to a scalar like _align, but are using keepdims=True
         """
         if axis is None:
-            return self[0,0]
+            return self[0, 0]
         else:
             return self
 
@@ -862,7 +862,7 @@ class matrix(N.ndarray):
                 [ 0.,  1.]])
 
         """
-        M,N = self.shape
+        M, N = self.shape
         if M == N:
             from numpy.dual import inv as func
         else:
@@ -997,7 +997,7 @@ class matrix(N.ndarray):
     H = property(getH, None, doc="hermitian (conjugate) transpose")
     I = property(getI, None, doc="inverse")
 
-def _from_string(str,gdict,ldict):
+def _from_string(str, gdict, ldict):
     rows = str.split(';')
     rowtup = []
     for row in rows:
@@ -1018,8 +1018,8 @@ def _from_string(str,gdict,ldict):
                     raise KeyError("%s not found" % (col,))
 
             coltup.append(thismat)
-        rowtup.append(concatenate(coltup,axis=-1))
-    return concatenate(rowtup,axis=0)
+        rowtup.append(concatenate(coltup, axis=-1))
+    return concatenate(rowtup, axis=0)
 
 
 def bmat(obj, ldict=None, gdict=None):
@@ -1084,10 +1084,10 @@ def bmat(obj, ldict=None, gdict=None):
         arr_rows = []
         for row in obj:
             if isinstance(row, N.ndarray):  # not 2-d
-                return matrix(concatenate(obj,axis=-1))
+                return matrix(concatenate(obj, axis=-1))
             else:
-                arr_rows.append(concatenate(row,axis=-1))
-        return matrix(concatenate(arr_rows,axis=0))
+                arr_rows.append(concatenate(row, axis=-1))
+        return matrix(concatenate(arr_rows, axis=0))
     if isinstance(obj, N.ndarray):
         return matrix(obj)
 
diff --git a/numpy/matrixlib/tests/test_defmatrix.py b/numpy/matrixlib/tests/test_defmatrix.py
index 7cfcdbe27..d1a4e4ab5 100644
--- a/numpy/matrixlib/tests/test_defmatrix.py
+++ b/numpy/matrixlib/tests/test_defmatrix.py
@@ -10,51 +10,51 @@ import collections
 
 class TestCtor(TestCase):
     def test_basic(self):
-        A = array([[1,2],[3,4]])
+        A = array([[1, 2], [3, 4]])
         mA = matrix(A)
         assert_(all(mA.A == A))
 
         B = bmat("A,A;A,A")
-        C = bmat([[A,A], [A,A]])
-        D = array([[1,2,1,2],
-                   [3,4,3,4],
-                   [1,2,1,2],
-                   [3,4,3,4]])
+        C = bmat([[A, A], [A, A]])
+        D = array([[1, 2, 1, 2],
+                   [3, 4, 3, 4],
+                   [1, 2, 1, 2],
+                   [3, 4, 3, 4]])
         assert_(all(B.A == D))
         assert_(all(C.A == D))
 
-        E = array([[5,6],[7,8]])
-        AEresult = matrix([[1,2,5,6],[3,4,7,8]])
-        assert_(all(bmat([A,E]) == AEresult))
+        E = array([[5, 6], [7, 8]])
+        AEresult = matrix([[1, 2, 5, 6], [3, 4, 7, 8]])
+        assert_(all(bmat([A, E]) == AEresult))
 
         vec = arange(5)
         mvec = matrix(vec)
-        assert_(mvec.shape == (1,5))
+        assert_(mvec.shape == (1, 5))
 
     def test_exceptions(self):
         # Check for TypeError when called with invalid string data.
         assert_raises(TypeError, matrix, "invalid")
 
     def test_bmat_nondefault_str(self):
-        A = array([[1,2],[3,4]])
-        B = array([[5,6],[7,8]])
-        Aresult = array([[1,2,1,2],
-                         [3,4,3,4],
-                         [1,2,1,2],
-                         [3,4,3,4]])
-        Bresult = array([[5,6,5,6],
-                         [7,8,7,8],
-                         [5,6,5,6],
-                         [7,8,7,8]])
-        mixresult = array([[1,2,5,6],
-                           [3,4,7,8],
-                           [5,6,1,2],
-                           [7,8,3,4]])
+        A = array([[1, 2], [3, 4]])
+        B = array([[5, 6], [7, 8]])
+        Aresult = array([[1, 2, 1, 2],
+                         [3, 4, 3, 4],
+                         [1, 2, 1, 2],
+                         [3, 4, 3, 4]])
+        Bresult = array([[5, 6, 5, 6],
+                         [7, 8, 7, 8],
+                         [5, 6, 5, 6],
+                         [7, 8, 7, 8]])
+        mixresult = array([[1, 2, 5, 6],
+                           [3, 4, 7, 8],
+                           [5, 6, 1, 2],
+                           [7, 8, 3, 4]])
         assert_(all(bmat("A,A;A,A") == Aresult))
-        assert_(all(bmat("A,A;A,A",ldict={'A':B}) == Aresult))
-        assert_raises(TypeError, bmat, "A,A;A,A",gdict={'A':B})
-        assert_(all(bmat("A,A;A,A",ldict={'A':A},gdict={'A':B}) == Aresult))
-        b2 = bmat("A,B;C,D",ldict={'A':A,'B':B},gdict={'C':B,'D':A})
+        assert_(all(bmat("A,A;A,A", ldict={'A':B}) == Aresult))
+        assert_raises(TypeError, bmat, "A,A;A,A", gdict={'A':B})
+        assert_(all(bmat("A,A;A,A", ldict={'A':A}, gdict={'A':B}) == Aresult))
+        b2 = bmat("A,B;C,D", ldict={'A':A,'B':B}, gdict={'C':B,'D':A})
         assert_(all(b2 == mixresult))
 
 
@@ -63,12 +63,12 @@ class TestProperties(TestCase):
         """Test whether matrix.sum(axis=1) preserves orientation.
         Fails in NumPy <= 0.9.6.2127.
         """
-        M = matrix([[1,2,0,0],
-                   [3,4,0,0],
-                   [1,2,1,2],
-                   [3,4,3,4]])
-        sum0 = matrix([8,12,4,6])
-        sum1 = matrix([3,7,6,14]).T
+        M = matrix([[1, 2, 0, 0],
+                   [3, 4, 0, 0],
+                   [1, 2, 1, 2],
+                   [3, 4, 3, 4]])
+        sum0 = matrix([8, 12, 4, 6])
+        sum1 = matrix([3, 7, 6, 14]).T
         sumall = 30
         assert_array_equal(sum0, M.sum(axis=0))
         assert_array_equal(sum1, M.sum(axis=1))
@@ -80,46 +80,46 @@ class TestProperties(TestCase):
 
 
     def test_prod(self):
-        x = matrix([[1,2,3],[4,5,6]])
+        x = matrix([[1, 2, 3], [4, 5, 6]])
         assert_equal(x.prod(), 720)
-        assert_equal(x.prod(0), matrix([[4,10,18]]))
-        assert_equal(x.prod(1), matrix([[6],[120]]))
+        assert_equal(x.prod(0), matrix([[4, 10, 18]]))
+        assert_equal(x.prod(1), matrix([[6], [120]]))
 
         assert_equal(np.prod(x), 720)
-        assert_equal(np.prod(x, axis=0), matrix([[4,10,18]]))
-        assert_equal(np.prod(x, axis=1), matrix([[6],[120]]))
+        assert_equal(np.prod(x, axis=0), matrix([[4, 10, 18]]))
+        assert_equal(np.prod(x, axis=1), matrix([[6], [120]]))
 
-        y = matrix([0,1,3])
+        y = matrix([0, 1, 3])
         assert_(y.prod() == 0)
 
     def test_max(self):
-        x = matrix([[1,2,3],[4,5,6]])
+        x = matrix([[1, 2, 3], [4, 5, 6]])
         assert_equal(x.max(), 6)
-        assert_equal(x.max(0), matrix([[4,5,6]]))
-        assert_equal(x.max(1), matrix([[3],[6]]))
+        assert_equal(x.max(0), matrix([[4, 5, 6]]))
+        assert_equal(x.max(1), matrix([[3], [6]]))
 
         assert_equal(np.max(x), 6)
-        assert_equal(np.max(x, axis=0), matrix([[4,5,6]]))
-        assert_equal(np.max(x, axis=1), matrix([[3],[6]]))
+        assert_equal(np.max(x, axis=0), matrix([[4, 5, 6]]))
+        assert_equal(np.max(x, axis=1), matrix([[3], [6]]))
 
     def test_min(self):
-        x = matrix([[1,2,3],[4,5,6]])
+        x = matrix([[1, 2, 3], [4, 5, 6]])
         assert_equal(x.min(), 1)
-        assert_equal(x.min(0), matrix([[1,2,3]]))
-        assert_equal(x.min(1), matrix([[1],[4]]))
+        assert_equal(x.min(0), matrix([[1, 2, 3]]))
+        assert_equal(x.min(1), matrix([[1], [4]]))
 
         assert_equal(np.min(x), 1)
-        assert_equal(np.min(x, axis=0), matrix([[1,2,3]]))
-        assert_equal(np.min(x, axis=1), matrix([[1],[4]]))
+        assert_equal(np.min(x, axis=0), matrix([[1, 2, 3]]))
+        assert_equal(np.min(x, axis=1), matrix([[1], [4]]))
 
     def test_ptp(self):
-        x = np.arange(4).reshape((2,2))
+        x = np.arange(4).reshape((2, 2))
         assert_(x.ptp() == 3)
         assert_(all(x.ptp(0) == array([2, 2])))
         assert_(all(x.ptp(1) == array([1, 1])))
 
     def test_var(self):
-        x = np.arange(9).reshape((3,3))
+        x = np.arange(9).reshape((3, 3))
         mx = x.view(np.matrix)
         assert_equal(x.var(ddof=0), mx.var(ddof=0))
         assert_equal(x.var(ddof=1), mx.var(ddof=1))
@@ -142,14 +142,14 @@ class TestProperties(TestCase):
         assert_(all(array(conjugate(transpose(B)) == mB.H)))
 
     def test_pinv(self):
-        x = matrix(arange(6).reshape(2,3))
+        x = matrix(arange(6).reshape(2, 3))
         xpinv = matrix([[-0.77777778,  0.27777778],
                         [-0.11111111,  0.11111111],
                         [ 0.55555556, -0.05555556]])
         assert_almost_equal(x.I, xpinv)
 
     def test_comparisons(self):
-        A = arange(100).reshape(10,10)
+        A = arange(100).reshape(10, 10)
         mA = matrix(A)
         mB = matrix(A) + 0.1
         assert_(all(mB == A+0.1))
@@ -173,34 +173,34 @@ class TestProperties(TestCase):
         assert_(all(abs(mB > 0)))
 
     def test_asmatrix(self):
-        A = arange(100).reshape(10,10)
+        A = arange(100).reshape(10, 10)
         mA = asmatrix(A)
-        A[0,0] = -10
-        assert_(A[0,0] == mA[0,0])
+        A[0, 0] = -10
+        assert_(A[0, 0] == mA[0, 0])
 
     def test_noaxis(self):
-        A = matrix([[1,0],[0,1]])
+        A = matrix([[1, 0], [0, 1]])
         assert_(A.sum() == matrix(2))
         assert_(A.mean() == matrix(0.5))
 
     def test_repr(self):
-        A = matrix([[1,0],[0,1]])
+        A = matrix([[1, 0], [0, 1]])
         assert_(repr(A) == "matrix([[1, 0],\n        [0, 1]])")
 
 class TestCasting(TestCase):
     def test_basic(self):
-        A = arange(100).reshape(10,10)
+        A = arange(100).reshape(10, 10)
         mA = matrix(A)
 
         mB = mA.copy()
-        O = ones((10,10), float64) * 0.1
+        O = ones((10, 10), float64) * 0.1
         mB = mB + O
         assert_(mB.dtype.type == float64)
         assert_(all(mA != mB))
         assert_(all(mB == mA+0.1))
 
         mC = mA.copy()
-        O = ones((10,10), complex128)
+        O = ones((10, 10), complex128)
         mC = mC * O
         assert_(mC.dtype.type == complex128)
         assert_(all(mA != mB))
@@ -272,12 +272,12 @@ class TestMatrixReturn(TestCase):
     def test_instance_methods(self):
         a = matrix([1.0], dtype='f8')
         methodargs = {
-            'astype' : ('intc',),
-            'clip' : (0.0, 1.0),
-            'compress' : ([1],),
-            'repeat' : (1,),
-            'reshape' : (1,),
-            'swapaxes' : (0,0),
+            'astype': ('intc',),
+            'clip': (0.0, 1.0),
+            'compress': ([1],),
+            'repeat': (1,),
+            'reshape': (1,),
+            'swapaxes': (0, 0),
             'dot': np.array([1.0]),
             }
         excluded_methods = [
@@ -305,23 +305,23 @@ class TestMatrixReturn(TestCase):
                 assert_(type(b) is matrix, "%s" % attrib)
         assert_(type(a.real) is matrix)
         assert_(type(a.imag) is matrix)
-        c,d = matrix([0.0]).nonzero()
+        c, d = matrix([0.0]).nonzero()
         assert_(type(c) is matrix)
         assert_(type(d) is matrix)
 
 
 class TestIndexing(TestCase):
     def test_basic(self):
-        x = asmatrix(zeros((3,2),float))
-        y = zeros((3,1),float)
-        y[:,0] = [0.8,0.2,0.3]
-        x[:,1] = y>0.5
-        assert_equal(x, [[0,1],[0,0],[0,0]])
+        x = asmatrix(zeros((3, 2), float))
+        y = zeros((3, 1), float)
+        y[:, 0] = [0.8, 0.2, 0.3]
+        x[:, 1] = y>0.5
+        assert_equal(x, [[0, 1], [0, 0], [0, 0]])
 
 
 class TestNewScalarIndexing(TestCase):
     def setUp(self):
-        self.a = matrix([[1, 2],[3,4]])
+        self.a = matrix([[1, 2], [3, 4]])
 
     def test_dimesions(self):
         a = self.a
@@ -331,64 +331,64 @@ class TestNewScalarIndexing(TestCase):
     def test_array_from_matrix_list(self):
         a = self.a
         x = array([a, a])
-        assert_equal(x.shape, [2,2,2])
+        assert_equal(x.shape, [2, 2, 2])
 
     def test_array_to_list(self):
         a = self.a
-        assert_equal(a.tolist(),[[1, 2], [3, 4]])
+        assert_equal(a.tolist(), [[1, 2], [3, 4]])
 
     def test_fancy_indexing(self):
         a = self.a
-        x = a[1, [0,1,0]]
+        x = a[1, [0, 1, 0]]
         assert_(isinstance(x, matrix))
         assert_equal(x, matrix([[3,  4,  3]]))
-        x = a[[1,0]]
+        x = a[[1, 0]]
         assert_(isinstance(x, matrix))
         assert_equal(x, matrix([[3,  4], [1, 2]]))
-        x = a[[[1],[0]],[[1,0],[0,1]]]
+        x = a[[[1], [0]], [[1, 0], [0, 1]]]
         assert_(isinstance(x, matrix))
         assert_equal(x, matrix([[4,  3], [1,  2]]))
 
     def test_matrix_element(self):
-        x = matrix([[1,2,3],[4,5,6]])
-        assert_equal(x[0][0],matrix([[1,2,3]]))
-        assert_equal(x[0][0].shape,(1,3))
-        assert_equal(x[0].shape,(1,3))
-        assert_equal(x[:,0].shape,(2,1))
+        x = matrix([[1, 2, 3], [4, 5, 6]])
+        assert_equal(x[0][0], matrix([[1, 2, 3]]))
+        assert_equal(x[0][0].shape, (1, 3))
+        assert_equal(x[0].shape, (1, 3))
+        assert_equal(x[:, 0].shape, (2, 1))
 
         x = matrix(0)
-        assert_equal(x[0,0],0)
-        assert_equal(x[0],0)
-        assert_equal(x[:,0].shape,x.shape)
+        assert_equal(x[0, 0], 0)
+        assert_equal(x[0], 0)
+        assert_equal(x[:, 0].shape, x.shape)
 
     def test_scalar_indexing(self):
-        x = asmatrix(zeros((3,2),float))
-        assert_equal(x[0,0],x[0][0])
+        x = asmatrix(zeros((3, 2), float))
+        assert_equal(x[0, 0], x[0][0])
 
     def test_row_column_indexing(self):
         x = asmatrix(np.eye(2))
-        assert_array_equal(x[0,:],[[1,0]])
-        assert_array_equal(x[1,:],[[0,1]])
-        assert_array_equal(x[:,0],[[1],[0]])
-        assert_array_equal(x[:,1],[[0],[1]])
+        assert_array_equal(x[0,:], [[1, 0]])
+        assert_array_equal(x[1,:], [[0, 1]])
+        assert_array_equal(x[:, 0], [[1], [0]])
+        assert_array_equal(x[:, 1], [[0], [1]])
 
     def test_boolean_indexing(self):
         A = arange(6)
-        A.shape = (3,2)
+        A.shape = (3, 2)
         x = asmatrix(A)
-        assert_array_equal(x[:,array([True,False])],x[:,0])
-        assert_array_equal(x[array([True,False,False]),:],x[0,:])
+        assert_array_equal(x[:, array([True, False])], x[:, 0])
+        assert_array_equal(x[array([True, False, False]),:], x[0,:])
 
     def test_list_indexing(self):
         A = arange(6)
-        A.shape = (3,2)
+        A.shape = (3, 2)
         x = asmatrix(A)
-        assert_array_equal(x[:,[1,0]],x[:,::-1])
-        assert_array_equal(x[[2,1,0],:],x[::-1,:])
+        assert_array_equal(x[:, [1, 0]], x[:, ::-1])
+        assert_array_equal(x[[2, 1, 0],:], x[::-1,:])
 
 class TestPower(TestCase):
     def test_returntype(self):
-        a = array([[0,1],[0,0]])
+        a = array([[0, 1], [0, 0]])
         assert_(type(matrix_power(a, 2)) is ndarray)
         a = mat(a)
         assert_(type(matrix_power(a, 2)) is matrix)
diff --git a/numpy/matrixlib/tests/test_multiarray.py b/numpy/matrixlib/tests/test_multiarray.py
index bed055615..fc5b1df17 100644
--- a/numpy/matrixlib/tests/test_multiarray.py
+++ b/numpy/matrixlib/tests/test_multiarray.py
@@ -5,14 +5,14 @@ from numpy.testing import *
 
 class TestView(TestCase):
     def test_type(self):
-        x = np.array([1,2,3])
-        assert_(isinstance(x.view(np.matrix),np.matrix))
+        x = np.array([1, 2, 3])
+        assert_(isinstance(x.view(np.matrix), np.matrix))
 
     def test_keywords(self):
-        x = np.array([(1,2)],dtype=[('a',np.int8),('b',np.int8)])
+        x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
         # We must be specific about the endianness here:
         y = x.view(dtype='<i2', type=np.matrix)
-        assert_array_equal(y,[[513]])
+        assert_array_equal(y, [[513]])
 
-        assert_(isinstance(y,np.matrix))
+        assert_(isinstance(y, np.matrix))
         assert_equal(y.dtype, np.dtype('<i2'))
diff --git a/numpy/matrixlib/tests/test_numeric.py b/numpy/matrixlib/tests/test_numeric.py
index 940bfc5d9..fa88f5288 100644
--- a/numpy/matrixlib/tests/test_numeric.py
+++ b/numpy/matrixlib/tests/test_numeric.py
@@ -6,5 +6,5 @@ from numpy import matrix
 
 class TestDot(TestCase):
     def test_matscalar(self):
-        b1 = matrix(ones((3,3),dtype=complex))
+        b1 = matrix(ones((3, 3), dtype=complex))
         assert_equal(b1*1.0, b1)
diff --git a/numpy/matrixlib/tests/test_regression.py b/numpy/matrixlib/tests/test_regression.py
index 9831f8131..4bbd44dcf 100644
--- a/numpy/matrixlib/tests/test_regression.py
+++ b/numpy/matrixlib/tests/test_regression.py
@@ -9,14 +9,14 @@ class TestRegression(TestCase):
     def test_kron_matrix(self,level=rlevel):
         """Ticket #71"""
         x = np.matrix('[1 0; 1 0]')
-        assert_equal(type(np.kron(x,x)),type(x))
+        assert_equal(type(np.kron(x, x)), type(x))
 
     def test_matrix_properties(self,level=rlevel):
         """Ticket #125"""
-        a = np.matrix([1.0],dtype=float)
+        a = np.matrix([1.0], dtype=float)
         assert_(type(a.real) is np.matrix)
         assert_(type(a.imag) is np.matrix)
-        c,d = np.matrix([0.0]).nonzero()
+        c, d = np.matrix([0.0]).nonzero()
         assert_(type(c) is np.matrix)
         assert_(type(d) is np.matrix)
 
@@ -25,10 +25,10 @@ class TestRegression(TestCase):
         def mul() :
             np.mat(np.eye(2))*np.ones(2)
 
-        self.assertRaises(ValueError,mul)
+        self.assertRaises(ValueError, mul)
 
     def test_matrix_std_argmax(self,level=rlevel):
         """Ticket #83"""
-        x = np.asmatrix(np.random.uniform(0,1,(3,3)))
+        x = np.asmatrix(np.random.uniform(0, 1, (3, 3)))
         self.assertEqual(x.std().shape, ())
         self.assertEqual(x.argmax().shape, ())