compiler: Cache finite-difference weight properties

Author: Codex

devito/finite_differences/differentiable.py

@@ -1111,6 +1111,57 @@ def dimension(self):
 
     weights = Array.initvalue
 
+    @cached_property
+    def symmetry(self):
+        """
+        The sign relating mirrored coefficients: `1` for symmetric weights,
+        `-1` for antisymmetric weights, or `None` otherwise.
+
+        An odd antisymmetric sequence must have a zero center coefficient.
+        """
+        weights = self.weights
+        if not weights:
+            return None
+
+        middle = len(weights) // 2
+        pairs = tuple(zip(weights[:middle],
+                          reversed(weights[middle + len(weights) % 2:])))
+
+        if all(left.equals(right) is True for left, right in pairs):
+            return sympy.S.One
+        if all(left.equals(-right) is True for left, right in pairs) and \
+           (len(weights) % 2 == 0 or weights[middle].equals(0) is True):
+            return sympy.S.NegativeOne
+
+        return None
+
+    @cached_property
+    def coefficient_span(self):
+        """
+        Paired weights and their offset within the original stencil.
+
+        Symmetric or antisymmetric weights retain their full span, including
+        symmetric zero padding. Otherwise, trim known zeros at both ends and
+        return rebuilt weights together with their starting offset. The
+        resulting weights may still have no symmetry.
+        """
+        if self.symmetry is not None:
+            return self, 0
+
+        weights = self.weights
+        first, last = 0, len(weights)
+        while first < last and weights[first].is_zero is True:
+            first += 1
+        while last > first and weights[last - 1].is_zero is True:
+            last -= 1
+
+        if first == 0 and last == len(weights):
+            return self, 0
+
+        d = self.dimension
+        dimension = d._rebuild(_min=d._min + first, _max=d._min + last - 1)
+        return self._rebuild(dimensions=dimension, initvalue=weights[first:last]), first
+
     def _xreplace(self, rule):
         if self in rule:
             return rule[self], True

tests/test_derivatives.py

@@ -941,6 +941,54 @@ def test_unexpand_space_interp_w_saved_timefunc(self):
         assert_structure(op, ['t,x,y,z', 't,x,y,z,i1', 't,x,y,z,i1,i0'])
 
 
+class TestWeights:
+
+    @pytest.mark.parametrize('coeffs,expected', [
+        ((1, 2, -2, -1), -1),
+        ((1, 2, 0, -2, -1), -1),
+        ((1, 2, 2, 1), 1),
+        ((1, 2, 3, 2, 1), 1),
+        ((1, 2, 3, -2, -1), None),
+        ((0, 0, 0), 1),
+        ((0,), 1),
+        ((3,), 1),
+        ((Symbol('a'), 0, -Symbol('a')), -1),
+        ((Symbol('a'), Symbol('b'), Symbol('a')), 1),
+        ((Symbol('a'), Symbol('b')), None),
+    ])
+    def test_symmetry(self, coeffs, expected):
+        i = StencilDimension('i', 0, len(coeffs) - 1)
+        weights = Weights(name='w', dimensions=i, initvalue=coeffs)
+
+        assert weights.symmetry == expected
+        assert weights._rebuild().symmetry == expected
+
+    @pytest.mark.parametrize('coeffs,expected,offset,sign', [
+        ((0, 1, 2, -2, -1), (1, 2, -2, -1), 1, -1),
+        ((1, 2, -2, -1, 0), (1, 2, -2, -1), 0, -1),
+        ((0, 0, 1, 2, 2, 1, 0), (1, 2, 2, 1), 2, 1),
+        ((0, 1, 2, -2, -1, 0), (0, 1, 2, -2, -1, 0), 0, -1),
+        ((0, 1, 2, 3, 0), (1, 2, 3), 1, None),
+        ((1, 2, 3), (1, 2, 3), 0, None),
+        ((0, 0, 0), (0, 0, 0), 0, 1),
+        ((0, Symbol('a'), -Symbol('a')), (Symbol('a'), -Symbol('a')), 1, -1),
+    ])
+    def test_coefficient_span(self, coeffs, expected, offset, sign):
+        i = StencilDimension('i', -3, len(coeffs) - 4)
+        weights = Weights(name='w', dimensions=i, initvalue=coeffs)
+        span, start = weights.coefficient_span
+
+        assert span.weights == expected
+        assert span.symmetry == sign
+        assert start == offset
+        assert span.dimension._min == i._min + offset
+        assert span.dimension._size == len(expected)
+        assert weights.coefficient_span[0] is span
+        assert weights._rebuild().coefficient_span == (span, start)
+        if coeffs == expected:
+            assert span is weights
+
+
 class TestTwoStageEvaluation:
 
     def test_exceptions(self):