misc: Add as_independent patch to mpatches directory

Author: JDBetteridge

devito/finite_differences/derivative.py

@@ -183,12 +183,12 @@ def __new__(cls, expr, *dims, **kwargs):
             fd_order = fcounter.values()
         else:
             # Default finite difference orders depending on input dimension (.dt or .dx)
-            fd_order = tuple([
+            fd_order = tuple(
                 expr.time_order
                 if getattr(d, 'is_Time', False)
                 else expr.space_order
                 for d in dcounter.keys()
-            ])
+            )
 
         # SymPy expects the list of variables w.r.t. which we differentiate to be a list
         # of 2-tuples: `(s, count)` where:
@@ -546,59 +546,59 @@ def _eval_expand_nest(self, **hints):
         Note that this is not always a valid expansion depending on the kwargs
         used to construct the derivative.
         '''
-        if isinstance(self.expr, self.__class__):
-            new_expr = self.expr.args[0]
-            new_dims = [
-                (d, ii)
-                for d, ii in zip(
-                    chain(self.dims, self.expr.dims),
-                    chain(self.deriv_order, self.expr.deriv_order)
-                )
-            ]
-            # This is necessary as tools.abc.Reconstructable._rebuild will copy
-            # all kwargs from the self object
-            # TODO: This dictionary merge needs to be a lot better
-            # EG: Don't actually expand if derivatives are incompatible
-            new_deriv_order = tuple(chain(self.deriv_order, self.expr.deriv_order))
-            # The `fd_order` may need to be reduced to construct the nested derivative
-            dcounter = defaultdict(int)
-            fcounter = defaultdict(int)
-            new_fd_order = tuple(chain(self.fd_order, self.expr.fd_order))
-            for d, do, fo in zip(new_dims, new_deriv_order, new_fd_order):
-                if isinstance(d, Iterable):
-                    dcounter[d[0]] += d[1]
-                    fcounter[d[0]] += fo
-                else:
-                    dcounter[d] += do
-                    fcounter[d] += fo
-            for (d, do), (_, fo) in zip(dcounter.items(), fcounter.items()):
-                if getattr(d, 'is_Time', False):
-                    dim_name = 'time'
-                    order = self.expr.time_order
-                else:
-                    dim_name = 'space'
-                    order = self.expr.space_order
-                if fo > order:
-                    if do > order:
-                        raise ValueError(
-                            f'Nested {do}-derivative constructed which is bigger '
-                            f'than the {dim_name}_order={order}'
-                        )
-                    else:
-                        warn(
-                            f'Nested derivative constructed with fd_order={fo}, '
-                            f'but {dim_name}_order={order}. Adjusting '
-                            f'fd_order={order} for the {d} dimension.'
-                        )
-                        fcounter[d] = order
-            new_kwargs = {
-                'deriv_order': tuple(dcounter.values()),
-                'fd_order': tuple(fcounter.values())
-            }
-            return self.func(new_expr, *dcounter.items(), **new_kwargs)
-        else:
+        if not isinstance(self.expr, self.__class__):
             return self
 
+        new_expr = self.expr.args[0]
+        new_dims = [
+            (d, ii)
+            for d, ii in zip(
+                chain(self.dims, self.expr.dims),
+                chain(self.deriv_order, self.expr.deriv_order)
+            )
+        ]
+        # This is necessary as tools.abc.Reconstructable._rebuild will copy
+        # all kwargs from the self object
+        # TODO: This dictionary merge needs to be a lot better
+        # EG: Don't actually expand if derivatives are incompatible
+        new_deriv_order = tuple(chain(self.deriv_order, self.expr.deriv_order))
+        # The `fd_order` may need to be reduced to construct the nested derivative
+        dcounter = defaultdict(int)
+        fcounter = defaultdict(int)
+        new_fd_order = tuple(chain(self.fd_order, self.expr.fd_order))
+        for d, do, fo in zip(new_dims, new_deriv_order, new_fd_order):
+            if isinstance(d, Iterable):
+                dcounter[d[0]] += d[1]
+                fcounter[d[0]] += fo
+            else:
+                dcounter[d] += do
+                fcounter[d] += fo
+        for (d, do), (_, fo) in zip(dcounter.items(), fcounter.items()):
+            if getattr(d, 'is_Time', False):
+                dim_name = 'time'
+                order = self.expr.time_order
+            else:
+                dim_name = 'space'
+                order = self.expr.space_order
+            if fo > order:
+                if do > order:
+                    raise ValueError(
+                        f'Nested {do}-derivative constructed which is bigger '
+                        f'than the {dim_name}_order={order}'
+                    )
+                else:
+                    warn(
+                        f'Nested derivative constructed with fd_order={fo}, '
+                        f'but {dim_name}_order={order}. Adjusting '
+                        f'fd_order={order} for the {d} dimension.'
+                    )
+                    fcounter[d] = order
+        new_kwargs = {
+            'deriv_order': tuple(dcounter.values()),
+            'fd_order': tuple(fcounter.values())
+        }
+        return self.func(new_expr, *dcounter.items(), **new_kwargs)
+
     def _eval_expand_mul(self, **hints):
         ''' Expands products, moving independent terms outside the derivative
         `Derivative(C·f(x)·g(c, y), x)

devito/finite_differences/differentiable.py

@@ -4,19 +4,15 @@
 
 import numpy as np
 import sympy
-from sympy.core.add import _addsort, _unevaluated_Add
-from sympy.core.mul import _keep_coeff, _mulsort, _unevaluated_Mul
+from sympy.core.add import _addsort
+from sympy.core.mul import _keep_coeff, _mulsort
 from sympy.core.decorators import call_highest_priority
 from sympy.core.evalf import evalf_table
-from sympy.core.symbol import Symbol
-from sympy.core.singleton import S
-from sympy.utilities.iterables import _sift_true_false
 try:
     from sympy.core.core import ordering_of_classes
 except ImportError:
     # Moved in 1.13
     from sympy.core.basic import ordering_of_classes
-from packaging.version import Version
 
 from devito.finite_differences.tools import make_shift_x0, coeff_priority
 from devito.logger import warning
@@ -440,61 +436,6 @@ 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)
-
-
-# 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

devito/mpatches/__init__.py

@@ -1 +1,2 @@
 from .rationaltools import *  # noqa
+from .asindependent import *  # noqa

devito/mpatches/asindependent.py

@@ -0,0 +1,73 @@
+"""Monkeypatch for as_independent required for Devito Derviative. """
+
+from packaging.version import Version
+
+import sympy
+from sympy.core.add import _unevaluated_Add
+from sympy.core.expr import Expr
+from sympy.core.mul import _unevaluated_Mul
+from sympy.core.symbol import Symbol
+from sympy.core.singleton import S
+
+"""
+Copy of upstream sympy methods, without docstrings, comments or typehints
+Imports are moved to the top
+"""
+if Version(sympy.__version__) < Version('1.15.0.dev0'):
+    def _sift_true_false(seq, keyfunc):
+        true = []
+        false = []
+        for i in seq:
+            if keyfunc(i):
+                true.append(i)
+            else:
+                false.append(i)
+        return true, false
+
+    def as_independent(self, *deps, as_Add=None, strict=True):
+        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)
+
+    # Monkeypatch the method
+    Expr.as_independent = as_independent