sympy: Rewrite the as_independent method as a monkeypatch

Author: JDBetteridge

devito/finite_differences/derivative.py

@@ -605,7 +605,7 @@ def _eval_expand_mul(self, **hints):
             --> C·g(y)·Derivative(f(x), x)`
         '''
         if self.expr.is_Mul:
-            ind, dep = self.expr.as_independent(*self.dims, as_Mul=True)
+            ind, dep = self.expr.as_independent(*self.dims, as_Add=False)
             return ind*self.func(dep, *self.args[1:])
         else:
             return self

devito/finite_differences/differentiable.py

@@ -4,8 +4,9 @@
 
 import numpy as np
 import sympy
-from sympy.core.add import _addsort
-from sympy.core.mul import _keep_coeff, _mulsort
+from sympy.core.symbol import Symbol
+from sympy.core.add import _addsort, _unevaluated_Add
+from sympy.core.mul import _keep_coeff, _mulsort, _unevaluated_Mul
 from sympy.core.decorators import call_highest_priority
 from sympy.core.evalf import evalf_table
 try:
@@ -113,73 +114,6 @@ def is_Staggered(self):
     def is_TimeDependent(self):
         return any(i.is_Time for i in self.dimensions)
 
-    def as_independent(self, *deps, **hint):
-        """
-        A near copy of sympy.core.expr.Expr.as_independent
-        with a bug fixed
-        """
-        from sympy import Symbol
-        from sympy.core.add import _unevaluated_Add
-        from sympy.core.mul import _unevaluated_Mul
-
-        from sympy.core.singleton import S
-        from sympy.utilities.iterables import sift
-
-        if self is S.Zero:
-            return (self, self)
-
-        func = self.func
-        if hint.get('as_Add', isinstance(self, Add)):
-            want = Add
-        else:
-            want = Mul
-
-        # sift out deps into symbolic and other and ignore
-        # all symbols but those that are in the free symbols
-        sym = set()
-        other = []
-        for d in deps:
-            if isinstance(d, Symbol):  # Symbol.is_Symbol is True
-                sym.add(d)
-            else:
-                other.append(d)
-
-        def has(e):
-            """return the standard has() if there are no literal symbols, else
-            check to see that symbol-deps are in the free symbols."""
-            has_other = e.has(*other)
-            if not sym:
-                return has_other
-            return has_other or e.has(*(e.free_symbols & sym))
-
-        if (want is not func or
-                not issubclass(func, Add) and not issubclass(func, Mul)):
-            if has(self):
-                return (want.identity, self)
-            else:
-                return (self, want.identity)
-        else:
-            if func is Add:
-                args = list(self.args)
-            else:
-                args, nc = self.args_cnc()
-
-        d = sift(args, has)
-        depend = d[True]
-        indep = d[False]
-
-        if func is Add:  # all terms were treated as commutative
-            return (Add(*indep), _unevaluated_Add(*depend))
-        else:  # handle noncommutative by stopping at first dependent term
-            for i, n in enumerate(nc):
-                if has(n):
-                    depend.extend(nc[i:])
-                    break
-                indep.append(n)
-            return Mul(*indep), (
-                Mul(*depend, evaluate=False) if nc else
-                _unevaluated_Mul(*depend))
-
     @cached_property
     def _fd(self):
         # Filter out all args with fd order too high
@@ -503,6 +437,62 @@ def has_free(self, *patterns):
             return all(i in self.free_symbols for i in patterns)
 
 
+def as_independent(self, *deps, as_Add, strict):
+    """
+    Copy of upstream sympy method, without docstrings, comments or typehints
+    Imports are moved to the top
+    """
+    if self is S.Zero:
+        return (self, self)
+
+    if as_Add is None:
+        as_Add = self.is_Add
+
+    syms, other = _sift_true_false(deps, lambda d: isinstance(d, Symbol))
+    syms_set = set(syms)
+
+    if other:
+        def has(e):
+            return e.has_xfree(syms_set) or e.has(*other)
+    else:
+        def has(e):
+            return e.has_xfree(syms_set)
+
+    if as_Add:
+        if not self.is_Add:
+            if has(self):
+                return (S.Zero, self)
+            else:
+                return (self, S.Zero)
+
+        depend, indep = _sift_true_false(self.args, has)
+        return (self.func(*indep), _unevaluated_Add(*depend))
+
+    else:
+        if not self.is_Mul:
+            if has(self):
+                return (S.One, self)
+            else:
+                return (self, S.One)
+
+        args, nc = self.args_cnc()
+        depend, indep = _sift_true_false(args, has)
+
+        for i, n in enumerate(nc):
+            if has(n):
+                depend.extend(nc[i:])
+                break
+            indep.append(n)
+
+        return self.func(*indep), _unevaluated_Mul(*depend)
+
+from packaging.version import Version
+
+# Monkeypatch the method
+if Version(sympy.__version__) < Version('1.15.0.dev0'):
+    Differentiable.as_independent = as_independent
+
+
 def highest_priority(DiffOp):
     # We want to get the object with highest priority
     # We also need to make sure that the object with the largest