pre-commit: apply on Python files

Author: jcarpent

benchmarks/bench-switch.py

@@ -7,10 +7,11 @@
 import timeit
 
 from IPython import get_ipython
+
 ipython = get_ipython()
 
 quat = eigenpy.Quaternion()
-a = [0., 0., 0.]
+a = [0.0, 0.0, 0.0]
 
 cmd1 = "timeit np.array(a)"
 print("\n")
@@ -50,7 +51,7 @@
 ipython.magic(cmd5)
 print("\n")
 
-a_matrix = np.matrix(a);
+a_matrix = np.matrix(a)
 cmd6 = "timeit np.asarray(a_matrix)"
 print(cmd6)
 ipython.magic(cmd6)

unittest/python/test_LDLT.py

@@ -4,20 +4,22 @@
 import numpy.linalg as la
 
 dim = 100
-A = np.random.rand(dim,dim)
+A = np.random.rand(dim, dim)
 
-A = (A + A.T)*0.5 + np.diag(10. + np.random.rand(dim))
+A = (A + A.T) * 0.5 + np.diag(10.0 + np.random.rand(dim))
 
 ldlt = eigenpy.LDLT(A)
 
 L = ldlt.matrixL()
 D = ldlt.vectorD()
 P = ldlt.transpositionsP()
 
-assert eigenpy.is_approx(np.transpose(P).dot(L.dot(np.diag(D).dot(np.transpose(L).dot(P)))),A)
+assert eigenpy.is_approx(
+    np.transpose(P).dot(L.dot(np.diag(D).dot(np.transpose(L).dot(P)))), A
+)
 
-X = np.random.rand(dim,20)
+X = np.random.rand(dim, 20)
 B = A.dot(X)
 X_est = ldlt.solve(B)
-assert eigenpy.is_approx(X,X_est)
-assert eigenpy.is_approx(A.dot(X_est),B)
+assert eigenpy.is_approx(X, X_est)
+assert eigenpy.is_approx(A.dot(X_est), B)

unittest/python/test_LLT.py

@@ -4,17 +4,17 @@
 import numpy.linalg as la
 
 dim = 100
-A = np.random.rand(dim,dim)
+A = np.random.rand(dim, dim)
 
-A = (A + A.T)*0.5 + np.diag(10. + np.random.rand(dim))
+A = (A + A.T) * 0.5 + np.diag(10.0 + np.random.rand(dim))
 
 llt = eigenpy.LLT(A)
 
 L = llt.matrixL()
-assert eigenpy.is_approx(L.dot(np.transpose(L)),A)
+assert eigenpy.is_approx(L.dot(np.transpose(L)), A)
 
-X = np.random.rand(dim,20)
+X = np.random.rand(dim, 20)
 B = A.dot(X)
 X_est = llt.solve(B)
-assert eigenpy.is_approx(X,X_est)
-assert eigenpy.is_approx(A.dot(X_est),B)
+assert eigenpy.is_approx(X, X_est)
+assert eigenpy.is_approx(A.dot(X_est), B)

unittest/python/test_MINRES.py

@@ -8,9 +8,9 @@
 
 minres = eigenpy.MINRES(A)
 
-X = np.random.rand(dim,20)
+X = np.random.rand(dim, 20)
 B = A.dot(X)
 X_est = minres.solve(B)
-print("A.dot(X_est):",A.dot(X_est))
-print("B:",B)
-assert eigenpy.is_approx(A.dot(X_est),B,1e-6)
+print("A.dot(X_est):", A.dot(X_est))
+print("B:", B)
+assert eigenpy.is_approx(A.dot(X_est), B, 1e-6)

unittest/python/test_complex.py

@@ -8,20 +8,22 @@
 rows = 10
 cols = 20
 
+
 def test(dtype):
-  Z = np.zeros((rows,cols),dtype=dtype)
-  Z.real = np.random.rand(rows,cols)
-  Z.imag = np.random.rand(rows,cols)
-
-  Z_real = real(Z)
-  assert (Z_real == Z.real).all()
-  Z_imag = imag(Z)
-  assert (Z_imag == Z.imag).all()
-
-  Y = np.ones((rows,cols))
-  Y_complex = ascomplex(Y)
-  assert (Y_complex.real == Y).all()
-  assert (Y_complex.imag == np.zeros((rows,cols))).all()
+    Z = np.zeros((rows, cols), dtype=dtype)
+    Z.real = np.random.rand(rows, cols)
+    Z.imag = np.random.rand(rows, cols)
+
+    Z_real = real(Z)
+    assert (Z_real == Z.real).all()
+    Z_imag = imag(Z)
+    assert (Z_imag == Z.imag).all()
+
+    Y = np.ones((rows, cols))
+    Y_complex = ascomplex(Y)
+    assert (Y_complex.real == Y).all()
+    assert (Y_complex.imag == np.zeros((rows, cols))).all()
+
 
 # Float
 test(np.csingle)

unittest/python/test_eigen_ref.py

@@ -1,31 +1,33 @@
 import numpy as np
 from eigen_ref import *
 
+
 def test(mat):
 
-  printMatrix(mat)
-  fill(mat,1.)
-  printMatrix(mat)
-  assert np.array_equal(mat,np.full(mat.shape,1.))
+    printMatrix(mat)
+    fill(mat, 1.0)
+    printMatrix(mat)
+    assert np.array_equal(mat, np.full(mat.shape, 1.0))
+
+    A_ref = asRef(mat.shape[0], mat.shape[1])
+    A_ref.fill(1.0)
+    A_ref2 = asRef(mat.shape[0], mat.shape[1])
 
-  A_ref = asRef(mat.shape[0],mat.shape[1])
-  A_ref.fill(1.)
-  A_ref2 = asRef(mat.shape[0],mat.shape[1])
+    assert np.array_equal(A_ref, A_ref2)
 
-  assert np.array_equal(A_ref,A_ref2)
+    A_ref2.fill(0)
+    assert np.array_equal(A_ref, A_ref2)
 
-  A_ref2.fill(0)
-  assert np.array_equal(A_ref,A_ref2)
+    ref = asRef(mat)
+    assert np.all(ref == mat)
 
-  ref = asRef(mat)
-  assert np.all(ref == mat)
+    const_ref = asConstRef(mat)
+    assert np.all(const_ref == mat)
 
-  const_ref = asConstRef(mat)
-  assert np.all(const_ref == mat)
 
 rows = 10
 cols = 30
 
-mat = np.ones((rows,cols),order='F')
+mat = np.ones((rows, cols), order="F")
 
 test(mat)

unittest/python/test_eigen_solver.py

@@ -1,16 +1,17 @@
 import eigenpy
+
 eigenpy.switchToNumpyArray()
 
 import numpy as np
 import numpy.linalg as la
 
 dim = 100
-A = np.random.rand(dim,dim)
+A = np.random.rand(dim, dim)
 
 es = eigenpy.EigenSolver(A)
 
 V = es.eigenvectors()
 D = es.eigenvalues()
 
-assert eigenpy.is_approx(A.dot(V).real,V.dot(np.diag(D)).real)
-assert eigenpy.is_approx(A.dot(V).imag,V.dot(np.diag(D)).imag)
+assert eigenpy.is_approx(A.dot(V).real, V.dot(np.diag(D)).real)
+assert eigenpy.is_approx(A.dot(V).imag, V.dot(np.diag(D)).imag)

unittest/python/test_geometry.py

@@ -2,83 +2,87 @@
 
 from geometry import *
 import numpy as np
-from numpy import cos,sin
+from numpy import cos, sin
 
 verbose = True
 
-def isapprox(a,b,epsilon=1e-6):
-    if issubclass(a.__class__,np.ndarray) and issubclass(b.__class__,np.ndarray):
-        return np.allclose(a,b,epsilon)
+
+def isapprox(a, b, epsilon=1e-6):
+    if issubclass(a.__class__, np.ndarray) and issubclass(b.__class__, np.ndarray):
+        return np.allclose(a, b, epsilon)
     else:
-        return abs(a-b)<epsilon
+        return abs(a - b) < epsilon
+
 
 # --- Quaternion ---------------------------------------------------------------
 # Coefficient initialisation
 verbose and print("[Quaternion] Coefficient initialisation")
-q = Quaternion(1,2,3,4)
+q = Quaternion(1, 2, 3, 4)
 q.normalize()
-assert(isapprox(np.linalg.norm(q.coeffs()),q.norm()))
-assert(isapprox(np.linalg.norm(q.coeffs()),1))
+assert isapprox(np.linalg.norm(q.coeffs()), q.norm())
+assert isapprox(np.linalg.norm(q.coeffs()), 1)
 
 # Coefficient-vector initialisation
 verbose and print("[Quaternion] Coefficient-vector initialisation")
-v = np.array([0.5,-0.5,0.5,0.5])
+v = np.array([0.5, -0.5, 0.5, 0.5])
 qv = Quaternion(v)
-assert(isapprox(qv.coeffs(), v))
+assert isapprox(qv.coeffs(), v)
 
 # Angle axis initialisation
 verbose and print("[Quaternion] AngleAxis initialisation")
 r = AngleAxis(q)
 q2 = Quaternion(r)
-assert(q==q)
-assert(isapprox(q.coeffs(),q2.coeffs()))
-assert(q2.isApprox(q2))
-assert(q2.isApprox(q2,1e-2))
+assert q == q
+assert isapprox(q.coeffs(), q2.coeffs())
+assert q2.isApprox(q2)
+assert q2.isApprox(q2, 1e-2)
 
 Rq = q.matrix()
 Rr = r.matrix()
-assert(isapprox(Rq.dot(Rq.T),np.eye(3)))
-assert(isapprox(Rr,Rq))
+assert isapprox(Rq.dot(Rq.T), np.eye(3))
+assert isapprox(Rr, Rq)
 
 # Rotation matrix initialisation
 verbose and print("[Quaternion] Rotation Matrix initialisation")
 qR = Quaternion(Rr)
-assert(q.isApprox(qR))
-assert(isapprox(q.coeffs(),qR.coeffs()))
+assert q.isApprox(qR)
+assert isapprox(q.coeffs(), qR.coeffs())
 
-assert(isapprox(qR[3],1./np.sqrt(30)))
+assert isapprox(qR[3], 1.0 / np.sqrt(30))
 try:
-   qR[5]
-   print("Error, this message should not appear.")
+    qR[5]
+    print("Error, this message should not appear.")
 except RuntimeError as e:
-  if verbose: print("As expected, caught exception: ", e)
+    if verbose:
+        print("As expected, caught exception: ", e)
 
 # --- Angle Vector ------------------------------------------------
-r = AngleAxis(.1,np.array([1,0,0],np.double))
-if verbose: print("Rx(.1) = \n\n",r.matrix(),"\n")
-assert( isapprox(r.matrix()[2,2],cos(r.angle)))
-assert( isapprox(r.axis,np.array([1.,0,0])) )
-assert( isapprox(r.angle,0.1) )
-assert(r.isApprox(r))
-assert(r.isApprox(r,1e-2))
+r = AngleAxis(0.1, np.array([1, 0, 0], np.double))
+if verbose:
+    print("Rx(.1) = \n\n", r.matrix(), "\n")
+assert isapprox(r.matrix()[2, 2], cos(r.angle))
+assert isapprox(r.axis, np.array([1.0, 0, 0]))
+assert isapprox(r.angle, 0.1)
+assert r.isApprox(r)
+assert r.isApprox(r, 1e-2)
 
-r.axis = np.array([0,1,0],np.double).T
-assert( isapprox(r.matrix()[0,0],cos(r.angle)))
+r.axis = np.array([0, 1, 0], np.double).T
+assert isapprox(r.matrix()[0, 0], cos(r.angle))
 
 ri = r.inverse()
-assert( isapprox(ri.angle,-.1) )
+assert isapprox(ri.angle, -0.1)
 
 R = r.matrix()
-r2 = AngleAxis(np.dot(R,R))
-assert( isapprox(r2.angle,r.angle*2) )
+r2 = AngleAxis(np.dot(R, R))
+assert isapprox(r2.angle, r.angle * 2)
 
 # --- USER FUNCTIONS -----------------------------------------------------------
 ro = testOutAngleAxis()
-assert(ro.__class__ == AngleAxis)
+assert ro.__class__ == AngleAxis
 res = testInAngleAxis(r)
-assert( res==r.angle )
+assert res == r.angle
 
 qo = testOutQuaternion()
-assert(qo.__class__ == Quaternion)
+assert qo.__class__ == Quaternion
 res = testInQuaternion(q)
-assert(q.norm() == res)
+assert q.norm() == res