Refactor chapter 13

Author: meuns

test/test_chapter13.py

@@ -6,9 +6,9 @@
 
 class TestChapter13(TestCase):
 
-    def test_13_1_2(self):
+    def setUp(self):
         """
-        Points as null vectors.
+        Initialize CGA.
         """
         g = [
             [+0, +0, +0, +0, -1],
@@ -18,16 +18,44 @@ def test_13_1_2(self):
             [-1, +0, +0, +1, +0],
         ]
 
-        GA, o, e_1, e_2, e_3, inf = Ga.build('o e1 e2 e3 inf', g=g)
+        self.ga, self.o, self.e_1, self.e_2, self.e_3, self.inf = Ga.build('o e1 e2 e3 inf', g=g)
 
-        def vector(x, y, z):
-            return x * e_1 + y * e_2 + z * e_3
+    def vector(self, x, y, z):
+        """
+        Make a vector.
+        """
+        return x * self.e_1 + y * self.e_2 + z * self.e_3
 
-        def point(v):
-            return o + v + S.Half * v * v * inf
+    def point(self, alpha, v):
+        """
+        Make a point.
+        """
+        return alpha * (self.o + v + S.Half * v * v * self.inf)
 
-        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)))
+    def dual_plane(self, n, delta):
+        """
+        Make a dual plane.
+        """
+        return n + delta * self.inf
+
+    def dual_sphere(self, alpha, c, r):
+        """
+        Make a dual sphere.
+        """
+        return alpha * (c - S.Half * r * r * self.inf)
+
+    def dual_im_sphere(self, alpha, c, r):
+        """
+        Make a dual imaginary sphere.
+        """
+        return alpha * (c + S.Half * r * r * self.inf)
+
+    def test_13_1_2(self):
+        """
+        Points as null vectors.
+        """
+        p = self.point(1, self.vector(Symbol('px', real=True), Symbol('py', real=True), Symbol('pz', real=True)))
+        q = self.point(1, self.vector(Symbol('qx', real=True), Symbol('qy', real=True), Symbol('qz', real=True)))
 
         self.assertEqual(p | q, -S.Half * q * q + p | q - S.Half * p * p)
         self.assertEqual(p | q, -S.Half * (q - p) * (q - p))
@@ -36,59 +64,33 @@ def test_13_1_3(self):
         """
         General vectors represent dual planes and spheres.
         """
-        g = [
-            [+0, +0, +0, +0, -1],
-            [+0, +1, +0, +0, +0],
-            [+0, +0, +1, +0, +0],
-            [+0, +0, +0, +1, +0],
-            [-1, +0, +0, +1, +0],
-        ]
-
-        GA, o, e_1, e_2, e_3, inf = Ga.build('o e1 e2 e3 inf', g=g)
-
-        def vector(x, y, z):
-            return x * e_1 + y * e_2 + z * e_3
-
-        # Point
-        def point(alpha, v):
-            return alpha * (o + v + S.Half * v * v * inf)
-
         alpha = Symbol('alpha', real=True)
-        p = point(alpha, vector(Symbol('px', real=True), Symbol('py', real=True), Symbol('pz', real=True)))
+        p = self.point(alpha, self.vector(Symbol('px', real=True), Symbol('py', real=True), Symbol('pz', real=True)))
         self.assertEqual(p | p, S.Zero)
-        self.assertEqual(inf | p, -alpha)
+        self.assertEqual(self.inf | p, -alpha)
 
         # Dual plane
-        def dual_plane(n, delta):
-            return n + delta * inf
-
         nx = Symbol('nx', real=True)
         ny = Symbol('ny', real=True)
         nz = Symbol('nz', real=True)
-        p = dual_plane(vector(nx, ny, nz), Symbol('delta', real=True))
+        p = self.dual_plane(self.vector(nx, ny, nz), Symbol('delta', real=True))
         self.assertEqual(p | p, nx * nx + ny * ny + nz * nz)
-        self.assertEqual(inf | p, S.Zero)
+        self.assertEqual(self.inf | p, S.Zero)
 
         # Dual sphere
-        def dual_sphere(alpha, c, r):
-            return alpha * (c - S.Half * r * r * inf)
-
-        def dual_im_sphere(alpha, c, r):
-            return alpha * (c + S.Half * r * r * inf)
-
         cx = Symbol('cx', real=True)
         cy = Symbol('cy', real=True)
         cz = Symbol('cz', real=True)
         r = Symbol('r', real=True)
 
-        c = point(1, vector(cx, cy, cz))
+        c = self.point(1, self.vector(cx, cy, cz))
         self.assertEqual(c * c, S.Zero)
-        self.assertEqual(-inf | c, S.One)
+        self.assertEqual(-self.inf | c, S.One)
 
-        s = dual_sphere(alpha, c, r)
+        s = self.dual_sphere(alpha, c, r)
         self.assertEqual(s | s, alpha * alpha * r * r)
-        self.assertEqual(-inf | s, alpha)
+        self.assertEqual(-self.inf | s, alpha)
 
-        im_s = dual_im_sphere(alpha, c, r)
+        im_s = self.dual_im_sphere(alpha, c, r)
         self.assertEqual(im_s | im_s, -alpha * alpha * r * r)
-        self.assertEqual(-inf | im_s, alpha)
+        self.assertEqual(-self.inf | im_s, alpha)