Fix the broken Sdop.__eq__, and add the missing __ne__ operators. (#193)

`__ne__` is needed by python 2 (https://stackoverflow.com/q/4352244/102441), else it defaults to `x is not y`

Also:
* move some tests that ended up in the wrong place after a merge/rebase
* use the helper alias methods in `Ga` to increase coverage

Author: eric-wieser

galgebra/mv.py

@@ -1626,19 +1626,19 @@ def Add(sdop1, sdop2):
                 raise TypeError("Neither argument is a Dop instance")
             return Sdop.Add(sdop1, sdop2)
 
-    def __eq__(self, sdop):
-        if isinstance(sdop, Sdop):
-            if self.Ga != sdop.Ga:
-                return False
-            self = Sdop.consolidate_coefs(self)
-            sdop = Sdop.consolidate_coefs(sdop)
-            if len(self.terms) != len(sdop.terms):
-                return False
-            if set(self.terms) != set(sdop.terms):
-                return False
-            return True
+    def __eq__(self, other):
+        if isinstance(other, Sdop):
+            if self.Ga != other.Ga:
+                return NotImplemented
+
+            diff = self - other
+            return len(diff.terms) == 0
         else:
-            return False
+            return NotImplemented
+
+    if sys.version_info.major < 3:
+        def __ne__(self, other):
+            return not (self == other)
 
     def __add__(self, sdop):
         return Sdop.Add(self, sdop)
@@ -1718,6 +1718,10 @@ def __eq__(self,A):
                 return True
             return False
 
+    if sys.version_info.major < 3:
+        def __ne__(self, other):
+            return not (self == other)
+
     def __init__(self, __arg, **kwargs):
         """
         The partial differential operator is a partial derivative with
@@ -2134,15 +2138,19 @@ def __lt__(self, dopr):  # < left contraction
     def __gt__(self, dopr):  # > right contraction
         return Dop.Mul(self, dopr, op='>')
 
-    def __eq__(self, dop):
-        if isinstance(dop, Dop):
-            if self.Ga != dop.Ga:
-                return False
+    def __eq__(self, other):
+        if isinstance(other, Dop):
+            if self.Ga != other.Ga:
+                return NotImplemented
 
-            diff = self - dop
-            return all(coef == S(0) for coef, _ in diff.terms)
+            diff = self - other
+            return len(diff.terms) == 0
         else:
-            return False
+            return NotImplemented
+
+    if sys.version_info.major < 3:
+        def __ne__(self, other):
+            return not (self == other)
 
     def __str__(self):
         if printer.GaLatexPrinter.latex_flg:

test/test_differential_ops.py

@@ -44,7 +44,7 @@ def test_empty_dop(self):
         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)
+        make_zero = ga.dop([])
         assert make_zero * v == 0
         assert make_zero * make_zero * v == 0
         assert (make_zero + make_zero) * v == 0
@@ -65,8 +65,13 @@ def test_misc(self):
         assert laplacian.is_scalar()
         assert not ga.grad.is_scalar()
 
+        # test comparison
         assert ga.grad == ga.grad
+        assert not (ga.grad != ga.grad)
         assert ga.grad != laplacian
+        assert not (ga.grad == laplacian)
+        assert ga.grad != object()
+        assert not (ga.grad == object())
 
         # inconsistent cmpflg, not clear which side the operator goes on
         with pytest.raises(ValueError):
@@ -108,8 +113,7 @@ def test_shorthand(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)
 
-        # TODO: __eq__ is broken, remove `repr` when it is fixed
-        assert repr(Sdop(x, ga=ga)) == repr(Sdop([(S(1), Pdop({x: 1}, ga=ga))], ga=ga))
+        assert Sdop(x, ga=ga) == Sdop([(S(1), Pdop({x: 1}, ga=ga))], ga=ga)
 
     def test_empty_sdop(self):
         """ Test that sdop with zero terms is equivalent to multiplying by zero """
@@ -123,18 +127,6 @@ def test_empty_sdop(self):
         assert (make_zero + make_zero) * v == 0
         assert (-make_zero) * v == 0
 
-
-class TestPdop(object):
-
-    def test_deprecation(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)
-
-        # passing `None` is a deprecate way to spell `{}`
-        with pytest.warns(DeprecationWarning):
-            p = Pdop(None, ga=ga)
-        assert p == Pdop({}, ga=ga)
-
     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)
@@ -152,3 +144,48 @@ def test_associativity_and_distributivity(self):
         # check multiplication is associative
         assert (20 * laplacian) * v == 20 * (laplacian * v) != 0
         assert (laplacian * laplacian) * v == laplacian * (laplacian * 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)
+        laplacian = ga.sdop((ga.grad * ga.grad).terms)
+        lap2 = laplacian*laplacian
+
+        # test comparison
+        assert lap2 == lap2
+        assert not (lap2 != lap2)
+        assert lap2 != laplacian
+        assert not (lap2 == laplacian)
+        assert lap2 != object()
+        assert not (lap2 == object())
+
+
+class TestPdop(object):
+
+    def test_deprecation(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)
+
+        # passing `None` is a deprecate way to spell `{}`
+        with pytest.warns(DeprecationWarning):
+            p = Pdop(None, ga=ga)
+        assert p == Pdop({}, ga=ga)
+
+    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)
+
+        pxa = ga.pdop({x: 1})
+        pxb = ga.pdop({x: 1})
+        p1 = ga.pdop({})
+
+        # test comparison
+        assert pxa == pxb
+        assert not (pxa != pxb)
+        assert p1 != pxa
+        assert not (p1 == pxa)
+        assert pxa != object()
+        assert not (pxa == object())