Merge branch 'main' into thg_subst_applier

pymbolic/geometric_algebra/mapper.py

@@ -324,11 +324,11 @@ def map_product(self, expr):
 
             result = new_result
 
-        from pymbolic.primitives import flattened_sum
+        from pymbolic.primitives import flattened_product, flattened_sum
         return flattened_sum([
-                    type(expr)(tuple([
+                    flattened_product([
                         self.rec(prod_term) for prod_term in prod_term_list
-                        ]))
+                        ])
                     for prod_term_list in result
                     ])
 

pymbolic/mapper/__init__.py

@@ -993,6 +993,11 @@ def __init__(self):
         super().__init__()
         self.result_cache = {}
 
+        from warnings import warn
+        warn("CachingMapperMixin is deprecated and will be removed "
+                "in version 2023.x. Use CachedMapper instead.",
+                DeprecationWarning, stacklevel=2)
+
     def rec(self, expr):
         try:
             return self.result_cache[expr]

pymbolic/primitives.py

@@ -145,6 +145,8 @@
 
 .. autofunction:: is_zero
 .. autofunction:: is_constant
+.. autofunction:: flattened_sum
+.. autofunction:: flattened_product
 .. autofunction:: register_constant_class
 .. autofunction:: unregister_constant_class
 .. autofunction:: variables
@@ -159,7 +161,6 @@
 .. autofunction:: make_sym_vector
 .. autofunction:: make_sym_array
 
-
 Constants
 ---------
 
@@ -1609,9 +1610,14 @@ def subscript(expression, index):
     return Subscript(expression, index)
 
 
-def flattened_sum(components):
-    # flatten any potential sub-sums
-    queue = list(components)
+def flattened_sum(terms):
+    r"""Recursively flattens all the top level :class:`Sum`\ s in *terms*.
+
+    :arg terms: an :class:`~collections.abc.Iterable` of expressions.
+    :returns: a :class:`Sum` expression or, if there is only one term in
+        the sum, the respective term.
+    """
+    queue = list(terms)
     done = []
 
     while queue:
@@ -1639,17 +1645,25 @@ def linear_combination(coefficients, expressions):
                  if coefficient and expression)
 
 
-def flattened_product(components):
-    # flatten any potential sub-products
-    queue = list(components)
+def flattened_product(terms):
+    r"""Recursively flattens all the top level :class:`Product`\ s in *terms*.
+
+    This operation does not change the order of the terms in the products, so
+    it does not require the product to be commutative.
+
+    :arg terms: an :class:`~collections.abc.Iterable` of expressions.
+    :returns: a :class:`Product` expression or, if there is only one term in
+        the product, the respective term.
+    """
+    queue = list(terms)
     done = []
 
     while queue:
         item = queue.pop(0)
 
         if is_zero(item):
             return 0
-        if is_zero(item-1):
+        if is_zero(item - 1):
             continue
 
         if isinstance(item, Product):