Merge pull request #177 from eric-wieser/test-dop

Add tests for Dop and fix bugs found

Author: utensil

galgebra/mv.py

@@ -1964,16 +1964,20 @@ def __init__(self, *args, **kwargs):
         self.title = None
 
         if len(args) == 2:
-            if len(args[0]) != len(args[1]):
+            coefs, pdiffs = args
+            if len(coefs) != len(pdiffs):
                 raise ValueError('In Dop.__init__ coefficent list and Pdop list must be same length.')
-            self.terms = tuple(zip(args[0], args[1]))
+            self.terms = tuple(zip(coefs, pdiffs))
         elif len(args) == 1:
-            if isinstance(args[0][0][0], Mv):  # Mv expansion [(Mv, Pdop)]
-                self.terms = tuple(args[0])
-            elif isinstance(args[0][0][0], Sdop):  # Sdop expansion [(Sdop, Mv)]
+            arg, = args
+            if len(arg) == 0:
+                self.terms = ()
+            elif isinstance(arg[0][0], Mv):  # Mv expansion [(Mv, Pdop)]
+                self.terms = tuple(arg)
+            elif isinstance(arg[0][0], Sdop):  # Sdop expansion [(Sdop, Mv)]
                 coefs = []
                 pdiffs = []
-                for (sdop, mv) in args[0]:
+                for (sdop, mv) in arg:
                     for (coef, pdiff) in sdop.terms:
                         if pdiff in pdiffs:
                             index = pdiffs.index(pdiff)
@@ -2037,23 +2041,18 @@ def Add(dop1, dop2):
             if dop1.cmpflg != dop2.cmpflg:
                 raise ValueError('In Dop.Add complement flags have different values: %s vs. %s' % (dop1.cmpflg, dop2.cmpflg))
 
-            coefs1, pdiffs1 = list(zip(*dop1.terms))
-            coefs2, pdiffs2 = list(zip(*dop2.terms))
-
-            pdiffs1 = list(pdiffs1)
-            pdiffs2 = list(pdiffs2)
+            pdiffs1 = [pdiff for _, pdiff in dop1.terms]
+            pdiffs2 = [pdiff for _, pdiff in dop2.terms]
 
             pdiffs = pdiffs1 + [x for x in pdiffs2 if x not in pdiffs1]
             coefs = len(pdiffs) * [S(0)]
 
-            for pdiff in pdiffs1:
+            for coef, pdiff in dop1.terms:
                 index = pdiffs.index(pdiff)
-                coef = coefs1[pdiffs1.index(pdiff)]
                 coefs[index] += coef
 
-            for pdiff in pdiffs2:
+            for coef, pdiff in dop2.terms:
                 index = pdiffs.index(pdiff)
-                coef = coefs2[pdiffs2.index(pdiff)]
                 coefs[index] += coef
 
             return Dop(coefs, pdiffs, cmpflg=dop1.cmpflg, ga=dop1.Ga)
@@ -2149,7 +2148,7 @@ def __truediv__(self, dopr):
             raise TypeError('In Dop.__truediv__ dopr must be a sympy scalar.')
         return Dop([
             (coef / dopr, pdiff) for (coef, pdiff) in self.terms
-        ], ga=self.Ga)
+        ], ga=self.Ga, cmpflg=self.cmpflg)
 
     if sys.version_info.major < 3:
         __div__ = __truediv__

test/test_differential_ops.py

@@ -0,0 +1,82 @@
+from sympy import symbols
+import pytest
+
+from galgebra.ga import Ga
+from galgebra.mv import Dop
+
+
+class TestDop(object):
+
+    def test_associativity_and_distributivity(self):
+        coords = x, y, z = symbols('x y z', real=True)
+        ga, ex, ey, ez = Ga.build('e*x|y|z', g=[1, 1, 1], coords=coords)
+        v = ga.mv('v', 'vector', f=True)
+        laplacian = ga.grad * ga.grad
+        rlaplacian = ga.rgrad * ga.rgrad
+
+        # check addition distributes
+        assert (laplacian + ga.grad) * v == laplacian * v + ga.grad * v != 0
+        assert (laplacian + 1234567) * v == laplacian * v + 1234567 * v != 0
+        # check subtraction distributes
+        assert (laplacian - ga.grad) * v == laplacian * v - ga.grad * v != 0
+        assert (laplacian - 1234567) * v == laplacian * v - 1234567 * v != 0
+        # check unary subtraction distributes
+        assert (-ga.grad) * v == -(ga.grad * v) != 0
+        # check division is associative
+        assert v * (ga.rgrad / 2) == (v * ga.rgrad) / 2 != 0
+        # check multiplication is associative
+        assert (20 * ga.grad) * v == 20 * (ga.grad * v) != 0
+        assert v * (ga.rgrad * 20) == (v * ga.rgrad) * 20 != 0
+        assert (ex ^ ga.grad) ^ v == ex ^ (ga.grad ^ v) != 0
+        assert (20 ^ ga.grad) ^ v == 20 ^ (ga.grad ^ v) != 0
+        assert v ^ (ga.rgrad ^ ex) == (v ^ ga.rgrad) ^ ex != 0
+        assert v ^ (ga.rgrad ^ 20) == (v ^ ga.rgrad) ^ 20 != 0
+
+    def test_empty_dop(self):
+        """ Test that dop with zero terms is equivalent to multiplying by zero """
+        coords = x, y, z = symbols('x y z', real=True)
+        ga, ex, ey, ez = Ga.build('e*x|y|z', g=[1, 1, 1], coords=coords)
+        v = ga.mv('v', 'vector', f=True)
+
+        make_zero = Dop([], ga=ga)
+        assert make_zero * v == 0
+        assert make_zero * make_zero * v == 0
+        assert (make_zero + make_zero) * v == 0
+        assert (-make_zero) * v == 0
+
+    def test_misc(self):
+        """ Other miscellaneous tests """
+        coords = x, y, z = symbols('x y z', real=True)
+        ga, ex, ey, ez = Ga.build('e*x|y|z', g=[1, 1, 1], coords=coords)
+        v = ga.mv('v', 'vector', f=True)
+        laplacian = ga.grad * ga.grad
+        rlaplacian = ga.rgrad * ga.rgrad
+
+        # laplacian is a scalar operator, so applying it from either side
+        # is the same
+        assert laplacian * v == v * rlaplacian
+
+        assert laplacian.is_scalar()
+        assert not ga.grad.is_scalar()
+
+        # inconsistent cmpflg, not clear which side the operator goes on
+        with pytest.raises(ValueError):
+            ga.grad + ga.rgrad
+        with pytest.raises(ValueError):
+            ga.grad * ga.rgrad
+
+    def test_mixed_algebras(self):
+        coords = x, y, z = symbols('x y z', real=True)
+        ga1, ex1, ey1, ez1 = Ga.build('e1*x|y|z', g=[1, 1, 1], coords=coords)
+        ga2, ex2, ey2, ez2 = Ga.build('e2*x|y|z', g=[1, 1, 1], coords=coords)
+        assert ga1 != ga2
+
+        v1 = ga1.mv('v', 'vector', f=True)
+        v2 = ga2.mv('v', 'vector', f=True)
+
+        with pytest.raises(ValueError):
+            ga1.grad * v2
+        with pytest.raises(ValueError):
+            v1 * ga2.rgrad
+        with pytest.raises(ValueError):
+            ga1.grad * ga2.grad