test file PEP8 fixes

theano/sandbox/linalg/tests/test_linalg.py

@@ -12,7 +12,7 @@ from theano import config
 
 # The one in comment are not tested...
 from theano.sandbox.linalg.ops import (cholesky,
-                                       Cholesky, # op class
+                                       Cholesky,  # op class
                                        CholeskyGrad,
                                        matrix_inverse,
                                        pinv,
@@ -111,7 +111,7 @@ def test_cholesky_and_cholesky_grad_shape():
 def test_inverse_correctness():
     rng = numpy.random.RandomState(utt.fetch_seed())
 
-    r = rng.randn(4,4).astype(theano.config.floatX)
+    r = rng.randn(4, 4).astype(theano.config.floatX)
 
     x = tensor.matrix()
     xi = matrix_inverse(x)
@@ -120,8 +120,8 @@ def test_inverse_correctness():
     assert ri.shape == r.shape
     assert ri.dtype == r.dtype
 
-    rir = numpy.dot(ri,r)
-    rri = numpy.dot(r,ri)
+    rir = numpy.dot(ri, r)
+    rri = numpy.dot(r, ri)
 
     assert _allclose(numpy.identity(4), rir), rir
     assert _allclose(numpy.identity(4), rri), rri
@@ -174,6 +174,7 @@ def test_inverse_singular():
         return
     assert False
 
+
 def test_inverse_grad():
     rng = numpy.random.RandomState(utt.fetch_seed())
     r = rng.randn(4, 4)
@@ -181,37 +182,39 @@ def test_inverse_grad():
 
     rng = numpy.random.RandomState(utt.fetch_seed())
 
-    r = rng.randn(4,4)
+    r = rng.randn(4, 4)
     tensor.verify_grad(matrix_inverse, [r], rng=numpy.random)
 
 
 def test_rop_lop():
     mx = tensor.matrix('mx')
     mv = tensor.matrix('mv')
-    v  = tensor.vector('v')
+    v = tensor.vector('v')
     y = matrix_inverse(mx).sum(axis=0)
 
     yv = tensor.Rop(y, mx, mv)
     rop_f = function([mx, mv], yv)
 
-    sy, _ = theano.scan( lambda i,y,x,v: (tensor.grad(y[i],x)*v).sum(),
-                       sequences = tensor.arange(y.shape[0]),
-                       non_sequences = [y,mx,mv])
-    scan_f = function([mx,mv], sy)
+    sy, _ = theano.scan(lambda i, y, x, v: (tensor.grad(y[i], x) * v).sum(),
+                       sequences=tensor.arange(y.shape[0]),
+                       non_sequences=[y, mx, mv])
+    scan_f = function([mx, mv], sy)
 
     rng = numpy.random.RandomState(utt.fetch_seed())
-    vx = numpy.asarray(rng.randn(4,4), theano.config.floatX)
-    vv = numpy.asarray(rng.randn(4,4), theano.config.floatX)
+    vx = numpy.asarray(rng.randn(4, 4), theano.config.floatX)
+    vv = numpy.asarray(rng.randn(4, 4), theano.config.floatX)
 
-    v1 = rop_f(vx,vv)
-    v2 = scan_f(vx,vv)
+    v1 = rop_f(vx, vv)
+    v2 = scan_f(vx, vv)
 
     assert _allclose(v1, v2), ('ROP mismatch: %s %s' % (v1, v2))
 
     raised = False
     try:
-        tmp = tensor.Rop(theano.clone(y,
-                                      replace={mx:break_op(mx)}), mx, mv)
+        tmp = tensor.Rop(
+            theano.clone(y, replace={mx: break_op(mx)}),
+            mx,
+            mv)
     except ValueError:
         raised = True
     if not raised:
@@ -223,7 +226,7 @@ def test_rop_lop():
     yv = tensor.Lop(y, mx, v)
     lop_f = function([mx, v], yv)
 
-    sy = tensor.grad((v*y).sum(), mx)
+    sy = tensor.grad((v * y).sum(), mx)
     scan_f = function([mx, v], sy)
 
     v1 = lop_f(vx, vv)
@@ -300,12 +303,14 @@ def test_diag():
     """
     Test that linalg.diag has the same behavior as numpy.diag.
     numpy.diag has two behaviors:
-    (1) when given a vector, it returns a matrix with that vector as the diagonal.
-    (2) when given a matrix, returns a vector which is the diagonal of the matrix.
-
-    (1) and (2) are tested by test_alloc_diag and test_extract_diag respectively.
-    This test makes sure that linalg.diag instantiates the right op based on the dimension of
-    the input.
+    (1) when given a vector, it returns a matrix with that vector as the
+    diagonal.
+    (2) when given a matrix, returns a vector which is the diagonal of the
+    matrix.
+
+    (1) and (2) are tested by test_alloc_diag and test_extract_diag
+    respectively. This test makes sure that linalg.diag instantiates
+    the right op based on the dimension of the input.
     """
 
     # test that it builds a matrix with given diagonal when using vector inputs
@@ -334,7 +339,7 @@ def test_extract_diag():
     g = extract_diag(x)
     f = theano.function([x], g)
 
-    for shp in [(2, 3), (3, 2), (3, 3), (1,1), (0,0)]:
+    for shp in [(2, 3), (3, 2), (3, 3), (1, 1), (0, 0)]:
         m = rng.rand(*shp).astype(config.floatX)
         v = numpy.diag(m)
         r = f(m)
@@ -362,7 +367,7 @@ def test_extract_diag():
 
 def test_extract_diag_grad():
     rng = numpy.random.RandomState(utt.fetch_seed())
-    x = rng.rand(5,4)
+    x = rng.rand(5, 4)
     tensor.verify_grad(extract_diag, [x], rng=rng)