Use assertEqual, assertNotEqual and assertProjEqual

Author: meuns

tests/test_chapter11.py

@@ -30,9 +30,9 @@ def test11_4(self):
         q = q.subs({q0: 1})
         r = r.subs({r0: 1})
 
-        self.assertEquals(p ^ q ^ r, p ^ (q - p) ^ (r - p))
-        self.assertEquals(p ^ q ^ r, p ^ (q_inf - p_inf) ^ (r_inf - p_inf))
-        self.assertEquals(p ^ q ^ r, ((p + q + r) / 3) ^ ((p ^ q) + (q ^ r) + (r ^ p)))
+        self.assertEqual(p ^ q ^ r, p ^ (q - p) ^ (r - p))
+        self.assertEqual(p ^ q ^ r, p ^ (q_inf - p_inf) ^ (r_inf - p_inf))
+        self.assertEqual(p ^ q ^ r, ((p + q + r) / 3) ^ ((p ^ q) + (q ^ r) + (r ^ p)))
 
     def test11_6(self):
         """
@@ -54,8 +54,8 @@ def test11_6(self):
             Ip_inv = GA.I_inv()
             Ir = e_0_inv < Ip
             Ir_inv = Ir.inv()
-            self.assertEquals(Ip, e_0 ^ Ir)
-            self.assertEquals(Ip, e_0 * Ir)
+            self.assertEqual(Ip, e_0 ^ Ir)
+            self.assertEqual(Ip, e_0 * Ir)
 
             p = GA.mv([1] + [Symbol('p%d' % i, real=True) for i in range(1, GA.n)], 'vector')
 
@@ -70,7 +70,7 @@ def test11_6(self):
             for k in range(1, GA.n):
                 A = reduce(Mv.__xor__, v[:k])
                 X = (p ^ A)
-                self.assertNotEquals(X, 0)
+                self.assertNotEqual(X, 0)
                 M = e_0_inv < (e_0 ^ X)
 
                 # Very slow
@@ -80,13 +80,13 @@ def test11_6(self):
                 def hat(A):
                     return ((-1) ** A.pure_grade()) * A
 
-                self.assertEquals(hat(A < Ir_inv), ((-1) ** (GA.n - 1)) * (hat(A) < Ir_inv))
+                self.assertEqual(hat(A < Ir_inv), ((-1) ** (GA.n - 1)) * (hat(A) < Ir_inv))
 
                 Xd = (p ^ A).dual()
-                self.assertEquals(Xd, (p ^ A) < Ip_inv)
-                self.assertEquals(Xd, p < (A < Ip_inv))
-                self.assertEquals(Xd, p < ((A < Ir_inv) * e_0_inv))
-                self.assertEquals(Xd, hat(A < Ir_inv) - e_0_inv * (p < hat(A < Ir_inv)))
+                self.assertEqual(Xd, (p ^ A) < Ip_inv)
+                self.assertEqual(Xd, p < (A < Ip_inv))
+                self.assertEqual(Xd, p < ((A < Ir_inv) * e_0_inv))
+                self.assertEqual(Xd, hat(A < Ir_inv) - e_0_inv * (p < hat(A < Ir_inv)))
                 # Very slow
                 # self.assertEquals(Xd, hat(A < Ir_inv) + e_0_inv * hat(M < Ir_inv))
                 # self.assertEquals(Xd, (e_0_inv - d_inv) * hat(M < Ir_inv))
@@ -104,15 +104,15 @@ def test11_12_1(self):
         p = e_0 + e_1
         q = e_0 + e_2
         d = e_2 - e_1
-        self.assertEquals(p ^ q, p ^ d)
-        self.assertEquals(p ^ q, q ^ d)
+        self.assertEqual(p ^ q, p ^ d)
+        self.assertEqual(p ^ q, q ^ d)
 
         r = e_0 + 2 * (e_2 - e_1)
         e = 2 * (e_2 - e_1)
         s = e_0 + 3 * (e_2 - e_1)
         t = 2 * (e_0 + e_2)
-        self.assertEquals(2 * (p ^ q), p ^ e)
-        self.assertEquals(2 * (p ^ q), p ^ t)
+        self.assertEqual(2 * (p ^ q), p ^ e)
+        self.assertEqual(2 * (p ^ q), p ^ t)
 
     def test11_12_2_1(self):
         """
@@ -124,7 +124,7 @@ def test11_12_2_1(self):
 
         L = (e_1 + 2 * e_2 - e_3) ^ (e_0 + e_1 - 3 * e_2)
         d = (e_0.inv() < (e_0 ^ L)) / (e_0.inv() < L)
-        self.assertEquals(d.norm(), sqrt(Rational(35, 6)))
+        self.assertEqual(d.norm(), sqrt(Rational(35, 6)))
 
     def test11_12_2_2(self):
         """
@@ -152,5 +152,5 @@ def test11_12_2_2(self):
         for i in range(11):
             t_value = Rational(i, 10)
             x_value = x_t.subs({t: t_value})
-            self.assertEquals(x_value ^ L, 0)
-            self.assertEquals(t_x.subs(list(zip([x_1, x_2, x_3], x_value.blade_coefs([e_1, e_2, e_3])))), t_value)
+            self.assertEqual(x_value ^ L, 0)
+            self.assertEqual(t_x.subs(list(zip([x_1, x_2, x_3], x_value.blade_coefs([e_1, e_2, e_3])))), t_value)

tests/test_chapter13.py

@@ -29,8 +29,8 @@ def point(v):
         p = point(vector(Symbol('px', real=True), Symbol('py', real=True), Symbol('pz', real=True)))
         q = point(vector(Symbol('qx', real=True), Symbol('qy', real=True), Symbol('qz', real=True)))
 
-        self.assertEquals(p | q, -S.Half * q * q + p | q - S.Half * p * p)
-        self.assertEquals(p | q, -S.Half * (q - p) * (q - p))
+        self.assertEqual(p | q, -S.Half * q * q + p | q - S.Half * p * p)
+        self.assertEqual(p | q, -S.Half * (q - p) * (q - p))
 
     def test_13_1_3(self):
         """
@@ -55,8 +55,8 @@ def point(alpha, v):
 
         alpha = Symbol('alpha', real=True)
         p = point(alpha, vector(Symbol('px', real=True), Symbol('py', real=True), Symbol('pz', real=True)))
-        self.assertEquals(p | p, S.Zero)
-        self.assertEquals(inf | p, -alpha)
+        self.assertEqual(p | p, S.Zero)
+        self.assertEqual(inf | p, -alpha)
 
         # Dual plane
         def dual_plane(n, delta):
@@ -66,8 +66,8 @@ def dual_plane(n, delta):
         ny = Symbol('ny', real=True)
         nz = Symbol('nz', real=True)
         p = dual_plane(vector(nx, ny, nz), Symbol('delta', real=True))
-        self.assertEquals(p | p, nx * nx + ny * ny + nz * nz)
-        self.assertEquals(inf | p, S.Zero)
+        self.assertEqual(p | p, nx * nx + ny * ny + nz * nz)
+        self.assertEqual(inf | p, S.Zero)
 
         # Dual sphere
         def dual_sphere(alpha, c, r):
@@ -82,13 +82,13 @@ def dual_im_sphere(alpha, c, r):
         r = Symbol('r', real=True)
 
         c = point(1, vector(cx, cy, cz))
-        self.assertEquals(c * c, S.Zero)
-        self.assertEquals(-inf | c, S.One)
+        self.assertEqual(c * c, S.Zero)
+        self.assertEqual(-inf | c, S.One)
 
         s = dual_sphere(alpha, c, r)
-        self.assertEquals(s | s, alpha * alpha * r * r)
-        self.assertEquals(-inf | s, alpha)
+        self.assertEqual(s | s, alpha * alpha * r * r)
+        self.assertEqual(-inf | s, alpha)
 
         im_s = dual_im_sphere(alpha, c, r)
-        self.assertEquals(im_s | im_s, -alpha * alpha * r * r)
-        self.assertEquals(-inf | im_s, alpha)
+        self.assertEqual(im_s | im_s, -alpha * alpha * r * r)
+        self.assertEqual(-inf | im_s, alpha)

tests/test_chapter2.py

@@ -2,7 +2,7 @@
 
 from functools import reduce
 from itertools import product
-from sympy import Symbol, Matrix, solve, solve_poly_system, cos, sin
+from sympy import S, Symbol, Matrix, solve, solve_poly_system, cos, sin
 from galgebra.ga import Ga
 from galgebra.mv import Mv
 
@@ -20,10 +20,10 @@ def test2_3_2(self):
         c = GA.mv('c', 'vector')
         alpha = Symbol('alpha', real=True)
 
-        self.assertEquals(a ^ b, -b ^ a)
-        self.assertEquals(a ^ (alpha * b), alpha * (a ^ b))
-        self.assertEquals(GA.mv(alpha, 'scalar') ^ b, alpha * b)
-        self.assertEquals(a ^ (b + c), (a ^ b) + (a ^ c))
+        self.assertEqual(a ^ b, -b ^ a)
+        self.assertEqual(a ^ (alpha * b), alpha * (a ^ b))
+        self.assertEqual(GA.mv(alpha, 'scalar') ^ b, alpha * b)
+        self.assertEqual(a ^ (b + c), (a ^ b) + (a ^ c))
 
     def test_2_4_2(self):
         """
@@ -45,16 +45,16 @@ def test_2_4_2(self):
         b = GA.mv((b_1, b_2, b_3), 'vector')
         c = GA.mv((c_1, c_2, c_3), 'vector')
 
-        self.assertEquals(a ^ b ^ c, a ^ (b ^ c))
-        self.assertEquals(a ^ b ^ c, (a ^ b) ^ c)
+        self.assertEqual(a ^ b ^ c, a ^ (b ^ c))
+        self.assertEqual(a ^ b ^ c, (a ^ b) ^ c)
 
         m = Matrix([
             [a_1, b_1, c_1],
             [a_2, b_2, c_2],
             [a_3, b_3, c_3]
         ])
 
-        self.assertEquals(a ^ b ^ c, m.det() * (e_1 ^ e_2 ^ e_3))
+        self.assertEqual(a ^ b ^ c, m.det() * (e_1 ^ e_2 ^ e_3))
 
     def test2_9_1(self):
         """
@@ -66,20 +66,20 @@ def test2_9_1(self):
         # Check for k in [0, R.n]
         for k in range(GA.n + 1):
             Ak = GA.mv('A', 'blade', k)
-            self.assertEquals(Ak.pure_grade(), k)
+            self.assertEqual(Ak.pure_grade(), k)
             grades = GA.grade_decomposition(Ak)
-            self.assertEquals(len(grades), 1)
-            self.assertEquals(list(grades.keys())[0], k)
+            self.assertEqual(len(grades), 1)
+            self.assertEqual(list(grades.keys())[0], k)
 
         # Check for k and l in [0, R.n]
         for k, l in product(range(GA.n + 1), range(GA.n + 1)):
             Ak = GA.mv('A', 'blade', k)
             Bl = GA.mv('B', 'blade', l)
             C = Ak ^ Bl
-            self.assertEquals(C.pure_grade(), 0 if C == 0 else k + l)
+            self.assertEqual(C.pure_grade(), 0 if C == 0 else k + l)
             grades = GA.grade_decomposition(C)
-            self.assertEquals(len(grades), 1)
-            self.assertEquals(list(grades.keys())[0], 0 if C == 0 else k + l)
+            self.assertEqual(len(grades), 1)
+            self.assertEqual(list(grades.keys())[0], 0 if C == 0 else k + l)
 
     def test2_9_5(self):
         """
@@ -91,22 +91,22 @@ def test2_9_5(self):
             a = [GA.mv('a%d' % i, 'vector') for i in range(k)]
             A = reduce(Mv.__xor__, a)
             A_rev = reduce(Mv.__xor__, reversed(a))
-            self.assertEquals(A_rev, A.rev())
-            self.assertEquals(A_rev, ((-1) ** ((k * (k - 1)) / 2)) * A)
+            self.assertEqual(A_rev, A.rev())
+            self.assertEqual(A_rev, ((-1) ** ((k * (k - 1)) / 2)) * A)
 
     def test2_12_1_1(self):
         """
         Compute the outer products of the following 3-space expressions,
         giving the result relative to the basis {1, e_1, e_2, e_3, e_1^e_2, e_1^e_3, e_2^e_3, e_1^e_2^e_3}.
         """
         GA, e_1, e_2, e_3 = Ga.build('e*1|2|3')
-        self.assertTrue((e_1 + e_2) ^ (e_1 + e_3) == (-e_1 ^ e_2) + (e_1 ^ e_3) + (e_2 ^ e_3))
-        self.assertTrue((e_1 + e_2 + e_3) ^ (2 * e_1) == -2 * (e_1 ^ e_2) - 2 * (e_1 ^ e_3))
-        self.assertTrue((e_1 - e_2) ^ (e_1 - e_3) == (e_1 ^ e_2) - (e_1 ^ e_3) + (e_2 ^ e_3))
-        self.assertTrue(
-            (e_1 + e_2) ^ (0.5 * e_1 + 2 * e_2 + 3 * e_3) == 1.5 * (e_1 ^ e_2) + 3 * (e_1 ^ e_3) + 3 * (e_2 ^ e_3))
-        self.assertTrue((e_1 ^ e_2) ^ (e_1 + e_3) == (e_1 ^ e_2 ^ e_3))
-        self.assertTrue((e_1 + e_2) ^ ((e_1 ^ e_2) + (e_2 ^ e_3)) == (e_1 ^ e_2 ^ e_3))
+        self.assertEqual((e_1 + e_2) ^ (e_1 + e_3), (-e_1 ^ e_2) + (e_1 ^ e_3) + (e_2 ^ e_3))
+        self.assertEqual((e_1 + e_2 + e_3) ^ (2 * e_1), -2 * (e_1 ^ e_2) - 2 * (e_1 ^ e_3))
+        self.assertEqual((e_1 - e_2) ^ (e_1 - e_3), (e_1 ^ e_2) - (e_1 ^ e_3) + (e_2 ^ e_3))
+        self.assertEqual(
+            (e_1 + e_2) ^ (0.5 * e_1 + 2 * e_2 + 3 * e_3), 1.5 * (e_1 ^ e_2) + 3 * (e_1 ^ e_3) + 3 * (e_2 ^ e_3))
+        self.assertEqual((e_1 ^ e_2) ^ (e_1 + e_3), (e_1 ^ e_2 ^ e_3))
+        self.assertEqual((e_1 + e_2) ^ ((e_1 ^ e_2) + (e_2 ^ e_3)), (e_1 ^ e_2 ^ e_3))
 
     def test2_12_1_2(self):
         """
@@ -115,10 +115,10 @@ def test2_12_1_2(self):
         """
         GA, e_1, e_2, e_3 = Ga.build('e*1|2|3')
         B = e_1 ^ (e_2 - e_3)
-        self.assertTrue(e_1 ^ B == 0)
-        self.assertFalse((e_1 + e_2) ^ B == 0)
-        self.assertFalse((e_1 + e_2 + e_3) ^ B == 0)
-        self.assertTrue((2 * e_1 - e_2 + e_3) ^ B == 0)
+        self.assertEqual(e_1 ^ B, 0)
+        self.assertNotEqual((e_1 + e_2) ^ B, 0)
+        self.assertNotEqual((e_1 + e_2 + e_3) ^ B, 0)
+        self.assertEqual((2 * e_1 - e_2 + e_3) ^ B, 0)
 
     def test2_12_1_3(self):
         """
@@ -129,7 +129,7 @@ def test2_12_1_3(self):
         a = e_1 + 2 * e_2
         b = -e_1 - e_2
         B = a ^ b
-        self.assertTrue(B == 1 * (e_1 ^ e_2))
+        self.assertEqual(B, 1 * (e_1 ^ e_2))
 
     def test2_12_1_4(self):
         """
@@ -150,12 +150,12 @@ def test2_12_1_4(self):
 
         # Solve the linear system
         R = solve([L.obj, M.obj], a, b, dict=True)  # TODO: fix this...
-        self.assertTrue(len(R), 1)
+        self.assertEqual(len(R), 1)
 
         # Replace symbols
         x = x.subs(R[0])
 
-        self.assertEquals(x, e_1 + 2 * e_2)
+        self.assertEqual(x, e_1 + 2 * e_2)
 
     def test2_12_1_5(self):
         """
@@ -170,7 +170,7 @@ def test2_12_1_5(self):
         for k, l in product(range(GA.n + 1), range(GA.n + 1)):
             C += A.get_grade(k) ^ B.get_grade(l)
 
-        self.assertTrue(C == (2 * e_1 + 3 * (e_3 ^ e_1) + 2 * (e_2 ^ e_3)))
+        self.assertEqual(C, (2 * e_1 + 3 * (e_3 ^ e_1) + 2 * (e_2 ^ e_3)))
 
     def test2_12_2_1(self):
         """
@@ -187,17 +187,17 @@ def test2_12_2_1(self):
         x = a * e_1
         y = b * (cos(t) * e_1 + sin(t) * e_2)
         B = x ^ y
-        self.assertTrue(B == (a * b * sin(t) * (e_1 ^ e_2)))
+        self.assertEqual(B, (a * b * sin(t) * (e_1 ^ e_2)))
 
         # Retrieve the parallelogram area from the 2-vector
         area = B.norm()
-        self.assertTrue(area == (a * b * sin(t)))
+        self.assertEqual(area, (a * b * sin(t)))
 
         # Compute the parallelogram area using the determinant
         x = [a, 0]
         y = [b * cos(t), b * sin(t)]
         area = Matrix([x, y]).det()
-        self.assertTrue(area == (a * b * sin(t)))
+        self.assertEqual(area, (a * b * sin(t)))
 
     def test2_12_2_2(self):
         """
@@ -217,7 +217,7 @@ def test2_12_2_2(self):
 
         cross = x_1 * y_2 - y_1 * x_2
 
-        self.assertTrue(cross == (a * b * sin(t)))
+        self.assertEqual(cross, (a * b * sin(t)))
 
     def test2_12_2_4(self):
         """
@@ -244,19 +244,19 @@ def test2_12_2_4(self):
         x = x_1 * a + x_2 * b + x_3 * c
 
         # Solve x_1
-        self.assertTrue((x ^ a) == (x_2 * (b ^ a) + x_3 * (c ^ a)))
-        self.assertTrue((x ^ a ^ b) == x_3 * (c ^ a ^ b))
-        self.assertTrue((x ^ a ^ b) * (c ^ a ^ b).inv() == GA.mv(x_3, 'scalar'))
+        self.assertEqual((x ^ a), (x_2 * (b ^ a) + x_3 * (c ^ a)))
+        self.assertEqual((x ^ a ^ b), x_3 * (c ^ a ^ b))
+        self.assertEqual((x ^ a ^ b) * (c ^ a ^ b).inv(), GA.mv(x_3, 'scalar'))
 
         # Solve x_2
-        self.assertTrue((x ^ b) == (x_1 * (a ^ b) + x_3 * (c ^ b)))
-        self.assertTrue((x ^ b ^ c) == x_1 * (a ^ b ^ c))
-        self.assertTrue((x ^ b ^ c) * (a ^ b ^ c).inv() == GA.mv(x_1, 'scalar'))
+        self.assertEqual((x ^ b), (x_1 * (a ^ b) + x_3 * (c ^ b)))
+        self.assertEqual((x ^ b ^ c), x_1 * (a ^ b ^ c))
+        self.assertEqual((x ^ b ^ c) * (a ^ b ^ c).inv(), GA.mv(x_1, 'scalar'))
 
         # Solve x_3
-        self.assertTrue((x ^ c) == (x_1 * (a ^ c) + x_2 * (b ^ c)))
-        self.assertTrue((x ^ c ^ a) == x_2 * (b ^ c ^ a))
-        self.assertTrue((x ^ c ^ a) * (b ^ c ^ a).inv() == GA.mv(x_2, 'scalar'))
+        self.assertEqual((x ^ c), (x_1 * (a ^ c) + x_2 * (b ^ c)))
+        self.assertEqual((x ^ c ^ a), x_2 * (b ^ c ^ a))
+        self.assertEqual((x ^ c ^ a) * (b ^ c ^ a).inv(), GA.mv(x_2, 'scalar'))
 
     def test2_12_2_5(self):
         """
@@ -331,10 +331,10 @@ def test2_12_2_6(self):
         result = solve_poly_system(system, unknowns)
         result = result[0]
 
-        self.assertTrue(result[0] == 0)
-        self.assertTrue(result[1] == 0)
-        self.assertTrue(result[2] == 0)
-        self.assertTrue(result[3] == 0)
+        self.assertEqual(result[0], S.Zero)
+        self.assertEqual(result[1], S.Zero)
+        self.assertEqual(result[2], S.Zero)
+        self.assertEqual(result[3], S.Zero)
 
     def test2_12_2_9(self):
         """
@@ -344,4 +344,4 @@ def test2_12_2_9(self):
             for k, l in product(range(GA.n + 1), range(GA.n + 1)):
                 Ak = GA.mv('A', 'blade', k)
                 Bl = GA.mv('B', 'blade', l)
-                self.assertEquals(Ak ^ Bl, (-1) ** (k * l) * (Bl ^ Ak))
+                self.assertEqual(Ak ^ Bl, (-1) ** (k * l) * (Bl ^ Ak))