tests: Add some tests for new functionality

Author: JDBetteridge

devito/finite_differences/derivative.py

@@ -105,8 +105,6 @@ def __new__(cls, expr, *dims, **kwargs):
                 expr = diffify(expr)
             except Exception as e:
                 raise ValueError("`expr` must be a Differentiable object") from e
-        if isinstance(expr, sympy.Number):
-            return 0
 
         # Validate `dims`. It can be:
         # - a single Dimension ie: x
@@ -131,22 +129,39 @@ def __new__(cls, expr, *dims, **kwargs):
             raise ValueError(
                 'Length of `deriv_order` does not match the length of dimensions'
             )
+        if any([not is_integer(d) or d < 0 for d in deriv_order]):
+            raise TypeError(
+                'Invalid type in `deriv_order`, all elements must be non-negative Python `int`s'
+            )
 
         # Count the number of derivatives for each dimension
         dcounter = defaultdict(int)
         for d, o in zip(dims, deriv_order):
             if isinstance(d, Iterable):
-                dcounter[d[0]] += d[1]
+                if not is_integer(d[1]) or d[1] < 0:
+                    raise TypeError(
+                        'Invalid type for derivative order, it must be non-negative Python `int`'
+                    )
+                else:
+                    dcounter[d[0]] += d[1]
             else:
                 dcounter[d] += o
 
         # Default finite difference orders depending on input dimension (.dt or .dx)
-        default_fdo = tuple([
-            expr.time_order
-            if getattr(d, 'is_Time', False)
-            else expr.space_order
-            for d in dcounter.keys()
-        ])
+        # It's possible that the expr is a `sympy.Number` at this point, which
+        # has derivative 0, unless we're taking a 0th derivative.
+        if isinstance(expr, sympy.Number):
+            if any(dcounter.values()):
+                return 0
+            else:
+                return expr
+        else:
+            default_fdo = tuple([
+                expr.time_order
+                if getattr(d, 'is_Time', False)
+                else expr.space_order
+                for d in dcounter.keys()
+            ])
 
         # SymPy expects the list of variable w.r.t. which we differentiate to be a list
         # of 2-tuple `(s, count)` where s is the entity to diff wrt and count is the order
@@ -253,12 +268,7 @@ def __call__(self, x0=None, fd_order=None, side=None, method=None, **kwargs):
         return self._rebuild(*self.args, **rkw)
 
     def _rebuild(self, *args, **kwargs):
-        if not args:
-            kwargs['preprocessed'] = True
-            expr = super()._rebuild(**kwargs)
-        else:
-            expr = super()._rebuild(*args, **kwargs)
-        return expr
+        return super()._rebuild(*args, **kwargs)
 
     func = _rebuild
 
@@ -495,6 +505,12 @@ def _eval_fd(self, expr, **kwargs):
         return res
 
     def _eval_expand_nest(self, **hints):
+        ''' Expands nested derivatives
+        `Derivative(Derivative(f(x), (x, b)), (x, a)) --> Derivative(f(x), (x, a+b))`
+        `Derivative(Derivative(f(x), (y, b)), (x, a)) --> Derivative(f(x), (x, a), (y, b))`
+        Note that this is not always a valid expansion depending on the kwargs
+        used to construct the derivative.
+        '''
         expr = self.args[0]
         if isinstance(expr, self.__class__):
             new_expr = expr.args[0]
@@ -514,6 +530,9 @@ def _eval_expand_nest(self, **hints):
             return self
 
     def _eval_expand_mul(self, **hints):
+        ''' Expands products, moving independent terms outside the derivative
+        `Derivative(C·f(x)·g(c, y), x) --> C·g(y)·Derivative(f(x), x)`
+        '''
         expr = self.args[0]
         if isinstance(expr, sympy.Mul):
             ind, dep = expr.as_independent(*self.dims, as_Mul=True)
@@ -522,6 +541,9 @@ def _eval_expand_mul(self, **hints):
             return self
 
     def _eval_expand_add(self, **hints):
+        ''' Expands sums, using linearity of derivative
+        `Derivative(f(x) + g(x), x) --> Derivative(f(x), x) + Derivative(g(x), x)`
+        '''
         expr = self.args[0]
         if isinstance(expr, sympy.Add):
             ind, dep = expr.as_independent(*self.dims, as_Add=True)

tests/test_derivatives.py

@@ -1,6 +1,6 @@
 import numpy as np
 import pytest
-from sympy import simplify, diff, Float
+from sympy import sympify, simplify, diff, Float, Symbol
 
 from devito import (Grid, Function, TimeFunction, Eq, Operator, NODE, cos, sin,
                     ConditionalDimension, left, right, centered, div, grad)
@@ -1023,3 +1023,124 @@ def bypass_uneval(expr):
     unevals = expr.find(EvalDerivative)
     mapper = {i: Add(*i.args) for i in unevals}
     return expr.xreplace(mapper)
+
+
+class TestExpansion:
+    @classmethod
+    def setup_class(cls):
+        cls.grid = Grid(shape=(11,), extent=(1,))
+        cls.x = cls.grid.dimensions[0]
+        cls.u = Function(name='u', grid=cls.grid, space_order=4)
+
+        a = cls.u.dx
+        cls.b = a.subs({cls.u: -5*cls.u.dx + 4*cls.u + 3})
+
+    def test_reconstructible(self):
+        ''' Check that devito.Derivatives are reconstructible from func and args
+        (as per sympy docs)
+        '''
+        du = self.u.dx
+        assert du.func(*du.args) == du
+        assert du.func(*du.args).args == (self.u, (self.x, 1))
+
+    def test_deriv_order(self):
+        ''' Check default simplification causes the same result
+        '''
+        du11 = Derivative(self.u, self.x, self.x)
+        du2 = Derivative(self.u, (self.x, 2))
+        assert du11 == du2
+        assert du11.deriv_order == du2.deriv_order
+
+    @pytest.mark.xfail(raises=ValueError)
+    def test_wrong_deriv_order(self):
+        ''' Check an exception is raises with incompatible arguments
+        '''
+        _ = Derivative(self.u, self.x, deriv_order=(2, 4))
+
+    @pytest.mark.xfail(raises=ValueError)
+    def test_no_derivative(self):
+        _ = Derivative(sympify(-1))
+
+    @pytest.mark.xfail(raises=ValueError)
+    def test_no_dimension(self):
+        _ = Derivative(sympify(-1), deriv_order=0)
+
+    def test_constant(self):
+        ''' Check constant derivative is zero for non-0th order derivatives
+        '''
+        assert Derivative(sympify(-1), (self.x, 1)) == 0
+        assert Derivative(sympify(-1), (self.x, 2)) == 0
+        assert Derivative(sympify(-1), (self.x, 0)) == -1
+
+    def test_dims_validation(self):
+        ''' Validate `dims` kwarg
+        '''
+        grid = Grid(shape=(11, 11, 11), extent=(1, 1, 1))
+        x, y, z = grid.dimensions
+        u = Function(name='u', grid=grid, space_order=4)
+
+        d = Derivative(u, x)
+        assert d.dims == (x, )
+        assert d.deriv_order == (1, )
+
+        d = Derivative(u, x, y)
+        assert d.dims == (x, y)
+        assert d.deriv_order == (1, 1)
+
+        d = Derivative(u, (x, 2))
+        assert d.dims == (x, )
+        assert d.deriv_order == (2, )
+
+        d = Derivative(u, (x, 2), (y, 2))
+        assert d.dims == (x, y)
+        assert d.deriv_order == (2, 2)
+
+        d = Derivative(u, (x, 2), y, x, (z, 3))
+        assert d.dims == (x, y, z)
+        assert d.deriv_order == (3, 1, 3)
+
+    def test_dims_exceptions(self):
+        ''' Check invalid dimensions and orders raise exceptions
+        '''
+        grid = Grid(shape=(11, 11, 11), extent=(1, 1, 1))
+        x, y, z = grid.dimensions
+        u = Function(name='u', grid=grid, space_order=4)
+
+        # Don't allow negative derivatives
+        with pytest.raises(TypeError):
+            _ = Derivative(u, (x, -1))
+
+        # Don't allow fractional derivatives
+        with pytest.raises(TypeError):
+            _ = Derivative(u, (x, 0.5))
+
+        # Don't allow common mistake
+        # NB: Derivative(u, x, y) is probably what was intended
+        with pytest.raises(TypeError):
+            _ = Derivative(u, (x, y))
+
+        # Don't allow derivative order to be symbolic
+        a = Symbol('a', integer=True)
+        with pytest.raises(TypeError):
+            _ = Derivative(u, (x, a))
+
+    def test_expand_mul(self):
+        ''' Check independent terms can be extracted from the derivative.
+        The multiply expansion is the only hint executed by default when
+        `.expand()` is called.
+        '''
+        expanded = Derivative(4*self.u - 5*Derivative(self.u, self.x) + 3, self.x)
+        assert self.b.expand() == expanded
+
+    def test_expand_add(self):
+        ''' Check linearity
+        '''
+        expanded = 4*Derivative(self.u, self.x)
+        expanded -= 5*Derivative(Derivative(self.u, self.x), self.x)
+        assert self.b.expand(add=True) == expanded
+
+    def test_expand_nest(self):
+        ''' Check valid nested derivative expands (combining x derivatives)
+        '''
+        expanded = 4*Derivative(self.u, self.x) - 5*Derivative(self.u, (self.x, 2))
+        assert self.b.expand(add=True, nest=True) == expanded