wip

Author: eric-wieser

galgebra/dop.py

@@ -71,12 +71,6 @@ def _eval_derivative_n_times_terms(terms, x, n):
 
 ################ Scalar Partial Differential Operator Class ############
 
-def _diff_op_apply(d, x):
-    if not isinstance(d, DiffOpExpr):
-        d = d * DiffOpPartial({})
-    return d._diff_op_apply(x)
-
-
 class _BaseDop(object):
     """ Base class for differential operators - used to avoid accidental promotion """
     pass
@@ -116,6 +110,20 @@ def __rsub__(self, x):
     def __call__(self, x):
         return self._diff_op_apply(x)
 
+def _diff_op_ify(x):
+    if isinstance(x, DiffOpExpr):
+        return x
+    elif isinstance(x, sympy.Add):
+        return DiffOpAdd(*(a for a in x.args))
+    elif isinstance(x, sympy.Mul):
+        return DiffOpMul(*(a for a in x.args))
+    else:
+        return x * DiffOpPartial({})
+
+def _diff_op_apply(d, x):
+    if not isinstance(d, DiffOpExpr):
+        d = d * DiffOpPartial({})
+    return _diff_op_ify(d)._diff_op_apply(x)
 
 
 def Sdop(*args):
@@ -176,11 +184,11 @@ def sort_key(self, order=None):
             # lower order derivatives first
             self.order,
             # sorted by symbol after that, after expansion
-            sorted([
+            tuple(sorted([
                 x.sort_key(order)
                 for x, k in self.pdiffs.items()
                 for i in range(k)
-            ])
+            ]))
         )
 
     def __new__(cls, __arg):
@@ -210,7 +218,7 @@ def __new__(cls, __arg):
         return self
 
     def _eval_derivative(self, x):
-        self._eval_derivative_n_times(x, 1)
+        return self._eval_derivative_n_times(x, 1)
 
     def _eval_derivative_n_times(self, x, n) -> 'Pdop':  # pdiff(self)
         # d is partial derivative
@@ -272,6 +280,9 @@ def __str__(self):
     def __repr__(self):
         return str(self)
 
+    def __srepr__(self):
+        return '{}({})'.format(type(self).__name__, self.pdiffs)
+
     def _hashable_content(self):
         from sympy.utilities import default_sort_key
         sorted_items = sorted(
@@ -349,15 +360,36 @@ def _diff_op_apply(self, x):
             x = r._diff_op_apply(x)
         return coeff * x
 
+    def diff(self, *args, **kwargs):
+        return super().diff(*args, simplify=False, **kwargs)
+
+    def _eval_derivative(self, x):
+        coeff, diff = self.args
+        return sympy.diff(coeff, x) * diff + coeff * sympy.diff(diff, x)
+
 
 class DiffOpAdd(DiffOpExpr, sympy.Add):
     identity = DiffOpZero()
 
+    @classmethod
+    def _from_args(self, args, is_commutative):
+        args = [_diff_op_ify(arg) for arg in args]
+        return super()._from_args(args, is_commutative)
+
     def _diff_op_apply(self, x):
         args = self.args
         assert args
         # avoid `sympy.Add` so that this works on multivectors
         return functools.reduce(operator.add, (_diff_op_apply(a, x) for a in args))
 
     def _eval_derivative_n_times(self, x, n):
-        return sympy.Add._eval_derivative_n_times(self, x, n)
+        return DiffOpAdd(*(a.diff(x, n) for a in self.args))
+
+    def _eval_derivative(self, x):
+        return DiffOpAdd(*(a.diff(x) for a in self.args))
+
+    def _eval_simplify(self, *args, **kwargs):
+        return self
+
+    def diff(self, *args, **kwargs):
+        return super().diff(*args, simplify=False, **kwargs)

galgebra/mv.py

@@ -1676,10 +1676,7 @@ def is_scalar(self):
 
     def components(self):
         return tuple(
-            Dop(dop._consolidate_terms(
-                (Mv(coef * base, ga=self.Ga), pdiff)
-                for (coef, pdiff) in sdop.terms
-            ), ga=self.Ga)
+            Dop([(base, sdop)], ga=self.Ga)
             for (sdop, base) in self.Dop_mv_expand()
         )
 
@@ -1710,7 +1707,7 @@ def Dop_mv_expand(self, modes=None):
                     coefs.append(dop.Sdop([(mv_coef, pdiff)]))
         if modes is not None:
             for i in range(len(coefs)):
-                coefs[i] = coefs[i].simplify(modes)
+                coefs[i] = coefs[i].simplify(modes=modes)
         terms = list(zip(coefs, bases))
         return sorted(terms, key=lambda x: self.Ga._all_blades_lst.index(x[1]))