Rework sympy to pymbolic mappers

sumpy/codegen.py

@@ -64,11 +64,9 @@
 
 
 __doc__ = """
-
 Conversion of :mod:`sympy` expressions to :mod:`loopy`
 ------------------------------------------------------
 
-.. autoclass:: SympyToPymbolicMapper
 .. autofunction:: to_loopy_insns
 """
 
@@ -78,26 +76,6 @@ def wrap_in_cse(expr: Expression,
     return prim.make_common_subexpression(expr, prefix, wrap_vars=False)
 
 
-# {{{ sympy -> pymbolic mapper
-
-_SPECIAL_FUNCTION_NAMES = frozenset(dir(sym.functions))
-
-
-class SympyToPymbolicMapper(sym.SympyToPymbolicMapper):
-    @override
-    def not_supported(self, expr: object) -> Expression:
-        if isinstance(expr, int):
-            return expr
-        elif getattr(expr, "is_Function", False):
-            func_name = sym.SympyToPymbolicMapper.function_name(self, expr)
-            return prim.Variable(func_name)(
-                    *tuple(self.rec(arg) for arg in expr.args))
-        else:
-            return sym.SympyToPymbolicMapper.not_supported(self, expr)
-
-# }}}
-
-
 # {{{ bessel -> loopy codegen
 
 BESSEL_PREAMBLE = """//CL//
@@ -758,8 +736,7 @@ def to_loopy_insns(
     assignments = list(assignments)
 
     # convert from sympy
-    sympy_conv = SympyToPymbolicMapper()
-    pymbolic_assignments = [(name, sympy_conv(expr)) for name, expr in assignments]
+    pymbolic_assignments = [(name, sym.to_pymbolic(expr)) for name, expr in assignments]
 
     flat = FlattenMapper()
     bdr = BesselDerivativeReplacer()

sumpy/e2p.py

@@ -107,12 +107,12 @@ def get_loopy_args(self):
         return gather_loopy_arguments((self.expansion, *tuple(self.kernels)))
 
     def get_kernel_scaling_assignment(self):
-        from sumpy.symbolic import SympyToPymbolicMapper
-        sympy_conv = SympyToPymbolicMapper()
+        from sumpy.symbolic import to_pymbolic
         return [lp.Assignment(id="kernel_scaling",
                     assignee="kernel_scaling",
-                    expression=sympy_conv(
-                        self.expansion.kernel.get_global_scaling_const()),
+                    expression=to_pymbolic(
+                        self.expansion.kernel.get_global_scaling_const(),
+                    ),
                     temp_var_type=lp.Optional(None),
                     )]
 # }}}

sumpy/kernel.py

@@ -580,7 +580,7 @@ def __str__(self) -> str:
 
     @override
     def get_expression(self, dist_vec: sym.Matrix) -> sym.Expr:
-        expr = sym.PymbolicToSympyMapperWithSymbols().to_expr(self.expression)
+        expr = sym.to_symbolic_expr(self.expression, symbols=True)
 
         if self.dim != len(dist_vec):
             raise ValueError(
@@ -594,7 +594,7 @@ def get_expression(self, dist_vec: sym.Matrix) -> sym.Expr:
 
     @override
     def get_global_scaling_const(self) -> sym.Expr:
-        return sym.PymbolicToSympyMapperWithSymbols().to_expr(self.global_scaling_const)
+        return sym.to_symbolic_expr(self.global_scaling_const, symbols=True)
 
     @override
     def get_derivative_taker(

sumpy/qbx.py

@@ -111,9 +111,7 @@ def get_cache_key(self):
                 tuple(self.value_dtypes))
 
     def _expand(self, sac, avec, bvec, rscale, isrc):
-        from sumpy.symbolic import PymbolicToSympyMapper
-        conv = PymbolicToSympyMapper()
-        strengths = [conv.to_expr(self.get_strength_or_not(isrc, idx))
+        strengths = [sym.to_symbolic_expr(self.get_strength_or_not(isrc, idx))
                      for idx in range(len(self.source_kernels))]
         return self.expansion.coefficients_from_source_vec(
             self.source_kernels, avec, bvec, rscale=rscale, weights=strengths,