compiler: Improve ComplexPart printing, adjust CI for coverage

Author: EdCaunt

.github/workflows/pytest-core-nompi.yml

@@ -30,8 +30,8 @@ jobs:
 
       matrix:
         name: [
-           pytest-ubuntu-py311-gcc11-noomp,
-           pytest-ubuntu-py312-gcc12-omp,
+           pytest-ubuntu-py311-gcc11-cxxnoomp,
+           pytest-ubuntu-py312-gcc12-cxxomp,
            pytest-ubuntu-py39-gcc7-omp,
            pytest-ubuntu-py310-gcc10-noomp,
            pytest-ubuntu-py312-gcc13-omp,
@@ -42,18 +42,18 @@ jobs:
         ]
         set: [base, adjoint]
         include:
-        - name: pytest-ubuntu-py311-gcc11-noomp
+        - name: pytest-ubuntu-py311-gcc11-cxxnoomp
           python-version: '3.11'
           os: ubuntu-22.04
           arch: "gcc-11"
-          language: "C"
+          language: "CXX"
           sympy: "1.11"
 
-        - name: pytest-ubuntu-py312-gcc12-omp
+        - name: pytest-ubuntu-py312-gcc12-cxxomp
           python-version: '3.12'
           os: ubuntu-24.04
           arch: "gcc-12"
-          language: "openmp"
+          language: "CXXopenmp"
           sympy: "1.13"
 
         - name: pytest-ubuntu-py39-gcc7-omp

devito/finite_differences/differentiable.py

@@ -647,6 +647,7 @@ def __str__(self):
 
 class ComplexPart(Differentiable, sympy.core.function.Application):
     """Abstract class for `Real`, `Imag`, or `Conj` of an expression"""
+    _name = None
 
     def __new__(cls, *args, **kwargs):
         if len(args) != 1:
@@ -670,17 +671,17 @@ def __str__(self):
 
 class Real(ComplexPart):
     """Get the real part of an expression"""
-    pass
+    _name = 'real'
 
 
 class Imag(ComplexPart):
     """Get the imaginary part of an expression"""
-    pass
+    _name = 'imag'
 
 
 class Conj(ComplexPart):
     """Get the complex conjugate of an expression"""
-    pass
+    _name = 'conj'
 
 
 class IndexSum(sympy.Expr, Evaluable):

devito/passes/iet/languages/C.py

@@ -57,13 +57,12 @@ def _print_ImaginaryUnit(self, expr):
         return '_Complex_I'
 
     def _print_Real(self, expr):
-        return (f'{self.func_prefix(expr)}real{self.func_literal(expr).lower()}'
+        return (f'{self.func_prefix(expr)}real{self.func_literal(expr)}'
                 f'({self._print(expr.args[0])})')
 
     def _print_Imag(self, expr):
-        return (f'{self.func_prefix(expr)}imag{self.func_literal(expr).lower()}'
+        return (f'{self.func_prefix(expr)}imag{self.func_literal(expr)}'
                 f'({self._print(expr.args[0])})')
 
     def _print_Conj(self, expr):
-        return (f'conj{self.func_literal(expr).lower()}'
-                f'({self._print(expr.args[0])})')
+        return (f'conj{self.func_literal(expr)}({self._print(expr.args[0])})')

devito/passes/iet/languages/CXX.py

@@ -104,14 +104,8 @@ class CXXPrinter(BasePrinter, CXX11CodePrinter):
     def _print_ImaginaryUnit(self, expr):
         return f'1i{self.prec_literal(expr).lower()}'
 
-    def _print_Real(self, expr):
-        return f'{self._ns}real({self._print(expr.args[0])})'
-
-    def _print_Imag(self, expr):
-        return f'{self._ns}imag({self._print(expr.args[0])})'
-
-    def _print_Conj(self, expr):
-        return f'{self._ns}conj({self._print(expr.args[0])})'
+    def _print_ComplexPart(self, expr):
+        return f'{self._ns}{expr._name}({self._print(expr.args[0])})'
 
     def _print_Cast(self, expr):
         # The CXX recommended way to cast is to use static_cast

tests/test_symbolics.py

@@ -7,7 +7,7 @@
 from sympy import Expr, Number, Symbol
 from devito import (Constant, Dimension, Grid, Function, solve, TimeFunction, Eq,  # noqa
                     Operator, SubDimension, norm, Le, Ge, Gt, Lt, Abs, sin, cos,
-                    Min, Max, Real, Imag, Conj, switchconfig)
+                    Min, Max, Real, Imag, Conj, configuration)
 from devito.finite_differences.differentiable import SafeInv, Weights
 from devito.ir import Expression, FindNodes, ccode
 from devito.symbolics import (retrieve_functions, retrieve_indexed, evalrel,  # noqa
@@ -886,90 +886,79 @@ def setup_basic(self, dtype):
         f_imag = Function(name='f_imag', grid=grid)
         return f, f_real, f_imag
 
-    def run_operator(self, eqs, language):
-        with switchconfig(language=language):
-            Operator(eqs)()
-
     def test_devito_print(self):
         f, _, _ = self.setup_basic(np.complex64)
 
         assert str(Real(f)) == 'Real(f(x))'
         assert str(Imag(f)) == 'Imag(f(x))'
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
-    def test_printing(self, language):
+    def test_printing(self):
         f, f_real, f_imag = self.setup_basic(np.complex64)
 
         eq_re = Eq(f_real, Real(f))
         eq_im = Eq(f_imag, Imag(f))
 
-        with switchconfig(language=language):
-            op = Operator([eq_re, eq_im])
+        op = Operator([eq_re, eq_im])
 
-        if language in ('CXX', 'CXXopenmp'):
+        if configuration['language'] in ('CXX', 'CXXopenmp'):
             assert "f_real[x + 1] = std::real(f[x + 1])" in str(op.ccode)
             assert "f_imag[x + 1] = std::imag(f[x + 1])" in str(op.ccode)
 
         else:
             assert "f_real[x + 1] = crealf(f[x + 1])" in str(op.ccode)
             assert "f_imag[x + 1] = cimagf(f[x + 1])" in str(op.ccode)
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
     @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
-    def test_trivial(self, language, dtype):
+    def test_trivial(self, dtype):
         f, f_real, f_imag = self.setup_basic(dtype)
 
         eq_re = Eq(f_real, Real(f+1.))
         eq_im = Eq(f_imag, Imag(f+1.))
 
-        self.run_operator([eq_re, eq_im], language)
+        Operator([eq_re, eq_im])()
 
         rcheck = np.array([2., 3., 4., 5., 6.])
         icheck = np.array([12., 11., 10., 9., 8.])
         assert np.all(np.isclose(f_real.data, rcheck))
         assert np.all(np.isclose(f_imag.data, icheck))
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
     @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
-    def test_trivial_imag(self, language, dtype):
+    def test_trivial_imag(self, dtype):
         f, f_real, f_imag = self.setup_basic(dtype)
 
         eq_re = Eq(f_real, Real(f+1j))
         eq_im = Eq(f_imag, Imag(f+1j))
 
-        self.run_operator([eq_re, eq_im], language)
+        Operator([eq_re, eq_im])()
 
         rcheck = np.array([1., 2., 3., 4., 5.])
         icheck = np.array([13., 12., 11., 10., 9.])
         assert np.all(np.isclose(f_real.data, rcheck))
         assert np.all(np.isclose(f_imag.data, icheck))
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
-    def test_deriv(self, language):
+    def test_deriv(self):
         f, f_real, f_imag = self.setup_basic(np.complex64)
 
         eq_re = Eq(f_real, Real(f.dx))
         eq_im = Eq(f_imag, Imag(f.dx))
 
-        self.run_operator([eq_re, eq_im], language)
+        Operator([eq_re, eq_im])()
 
         assert np.all(np.isclose(f_real.data, 1.))
         assert np.all(np.isclose(f_imag.data, -1.))
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
-    def test_outer_deriv(self, language):
+    def test_outer_deriv(self):
         f, f_real, f_imag = self.setup_basic(np.complex64)
 
         eq_re = Eq(f_real, Real(f).dx)
         eq_im = Eq(f_imag, Imag(f).dx)
 
-        self.run_operator([eq_re, eq_im], language)
+        Operator([eq_re, eq_im])()
 
         assert np.all(np.isclose(f_real.data, 1.))
         assert np.all(np.isclose(f_imag.data, -1.))
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
-    def test_mul(self, language):
+    def test_mul(self):
         grid = Grid(shape=(5,))
 
         f = Function(name='f', grid=grid, dtype=np.complex64)
@@ -989,22 +978,21 @@ def test_mul(self, language):
         eq_fh_re = Eq(fh_re, Real(f*h))
         eq_fh_im = Eq(fh_im, Imag(f*h))
 
-        self.run_operator([eq_fg_re, eq_fg_im, eq_fh_re, eq_fh_im], language)
+        Operator([eq_fg_re, eq_fg_im, eq_fh_re, eq_fh_im])()
 
         assert np.all(np.isclose(fg_re.data, 2.))
         assert np.all(np.isclose(fg_im.data, 2.))
 
         assert np.all(np.isclose(fh_re.data, -2.))
         assert np.all(np.isclose(fh_im.data, 2.))
 
-    @pytest.mark.parametrize('language', ['C', 'CXX', 'CXXopenmp'])
-    def test_conj(self, language):
+    def test_conj(self):
         grid = Grid(shape=(5,))
         f = Function(name='f', grid=grid, dtype=np.complex64)
         g = Function(name='g', grid=grid, dtype=np.complex64)
 
         f.data[:] = np.arange(5) + 1j*np.arange(5)[::-1]
 
-        self.run_operator([Eq(g, Conj(f))], language)
+        Operator([Eq(g, Conj(f))])()
 
         assert np.all(np.isclose(g.data, np.conj(f.data)))