Using is_uniform to avoid repeated checks (#1517)

Now we have the `is_uniform` attribute; this PR uses it to speed up
the match test with `SequenceBlank` and `SequenceNullBlank`. Also,
ensure that this property is computed and stored in list/expression
creation operations (`Table`, `Sum`, `Product`).

* using `is_uniform` property in matching `SequenceBlank` and
`SequenceNullBlank` patterns
* `get_result` now accepts an optional attribute `is_uniform` to set this property on its result.
* `Table`, `Sum`, and `Product` now set the element_property `is_uniform` to provide a faster evaluation of large lists.
* convert_expression_elements now handles is_uniform
* Start a workflow to benchmark some basic evaluations and pattern
matching.

Author: mmatera

mathics/builtin/arithmetic.py

@@ -42,7 +42,7 @@
     Test,
 )
 from mathics.core.convert.sympy import SympyExpression, from_sympy
-from mathics.core.element import BaseElement
+from mathics.core.element import BaseElement, ElementsProperties
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.expression_predefined import (
@@ -784,8 +784,12 @@ class Product(IterationFunction, SympyFunction, PrefixOperator):
     sympy_name = "Product"
     throw_iterb = False
 
-    def get_result(self, elements):
-        return Expression(SymbolTimes, *elements)
+    def get_result(self, elements, is_uniform=False):
+        return Expression(
+            SymbolTimes,
+            *elements,
+            elements_properties=ElementsProperties(is_uniform=is_uniform),
+        )
 
     def to_sympy(self, expr, **kwargs):
         if expr.has_form("Product", 2) and expr.elements[1].has_form("List", 3):
@@ -1021,8 +1025,12 @@ class Sum(IterationFunction, SympyFunction, PrefixOperator):
     # Do not throw warning message for symbolic iteration bounds
     throw_iterb = False
 
-    def get_result(self, elements) -> Expression:
-        return Expression(SymbolPlus, *elements)
+    def get_result(self, elements, is_uniform=False) -> Expression:
+        return Expression(
+            SymbolPlus,
+            *elements,
+            elements_properties=ElementsProperties(is_uniform=is_uniform),
+        )
 
     def to_sympy(self, expr, **kwargs) -> Optional[SympyExpression]:
         """

mathics/builtin/functional/apply_fns_to_lists.py

@@ -8,7 +8,7 @@
 Many mathematical functions are automatically taken to be "listable", so that \
 they are always applied to every element in a list.
 """
-
+from dataclasses import replace as dc_replace
 from typing import Iterable
 
 from mathics.core.atoms import Integer, Integer0, Integer1, Integer3
@@ -94,7 +94,10 @@ def callback(level):
             if isinstance(level, Atom):
                 return level
             else:
-                return Expression(f, *level.elements)
+                elem_prop = level.elements_properties
+                if elem_prop is not None:
+                    elem_prop = dc_replace(elem_prop, elements_fully_evaluated=False)
+                return Expression(f, *level.elements, elements_properties=elem_prop)
 
         heads = self.get_option(options, "Heads", evaluation) is SymbolTrue
         result, _ = walk_levels(expr, start, stop, heads=heads, callback=callback)
@@ -154,6 +157,10 @@ def callback(level):
 
         heads = self.get_option(options, "Heads", evaluation) is SymbolTrue
         result, _ = walk_levels(expr, start, stop, heads=heads, callback=callback)
+        elem_prop = result.elements_properties
+        if elem_prop is not None:
+            elem_prop.elements_fully_evaluated = False
+        result.elements_properties
 
         return result
 
@@ -288,6 +295,9 @@ def callback(level, pos: Iterable):
         result, depth = walk_levels(
             expr, start, stop, heads=heads, callback=callback, include_pos=True
         )
+        elem_prop = result.elements_properties
+        if elem_prop is not None:
+            elem_prop.elements_fully_evaluated = False
 
         return result
 

mathics/builtin/list/constructing.py

@@ -566,10 +566,12 @@ class Table(IterationFunction):
 
     summary_text = "make a table of values of an expression"
 
-    def get_result(self, elements) -> ListExpression:
+    def get_result(self, elements, is_uniform=False) -> ListExpression:
         return ListExpression(
             *elements,
-            elements_properties=ElementsProperties(elements_fully_evaluated=True),
+            elements_properties=ElementsProperties(
+                elements_fully_evaluated=True, is_uniform=is_uniform
+            ),
         )
 
 

mathics/builtin/patterns/basic.py

@@ -19,15 +19,15 @@
     BLANKSEQUENCE_GENERAL_PATTERN_SORT_KEY,
     BLANKSEQUENCE_WITH_PATTERN_PATTERN_SORT_KEY,
 )
-from mathics.core.symbols import BaseElement
+from mathics.core.symbols import BaseElement, Symbol
 
 # This tells documentation how to sort this module
 sort_order = "mathics.builtin.rules-and-patterns.basic"
 
 
 class _Blank(PatternObject, ABC):
     arg_counts = [0, 1]
-
+    target_head: OptionalType[Symbol]
     _instance = None
 
     def __new__(cls, *args, **kwargs):
@@ -49,12 +49,14 @@ def init(
     ) -> None:
         super().init(expr, evaluation=evaluation)
         if expr.elements:
-            self.head = expr.elements[0]
+            target_head = expr.elements[0]
+            assert isinstance(target_head, Symbol)
+            self.target_head = target_head
         else:
-            # FIXME: elswhere, some code wants to
+            # FIXME: elsewhere, some code wants to
             # get the attributes of head.
             # So is this really the best thing to do here?
-            self.head = None
+            self.target_head = None
 
 
 class Blank(_Blank):
@@ -100,15 +102,17 @@ class Blank(_Blank):
     summary_text = "match to any single expression"
 
     def match(self, expression: BaseElement, pattern_context: dict):
+        if expression.has_form("Sequence", 0):
+            return
+
+        target_head = self.target_head
+        if target_head is not None and expression.get_head() is not target_head:
+            return
+
+        # Match!
         vars_dict = pattern_context["vars_dict"]
         yield_func = pattern_context["yield_func"]
-
-        if not expression.has_form("Sequence", 0):
-            if self.head is not None:
-                if expression.get_head().sameQ(self.head):
-                    yield_func(vars_dict, None)
-            else:
-                yield_func(vars_dict, None)
+        yield_func(vars_dict, None)
 
     @property
     def element_order(self):
@@ -157,19 +161,26 @@ class BlankNullSequence(_Blank):
 
     def match(self, expression: Expression, pattern_context: dict):
         """Match with a BlankNullSequence"""
-        vars_dict = pattern_context["vars_dict"]
-        yield_func = pattern_context["yield_func"]
-        elements = expression.get_sequence()
-        if self.head:
-            ok = True
+
+        target_head = self.target_head
+        if target_head:
+            elements = expression.get_sequence()
+            is_uniform = False
+            if isinstance(expression, Expression):
+                element_properties = expression.elements_properties
+                if element_properties is not None:
+                    is_uniform = element_properties.is_uniform
             for element in elements:
-                if element.get_head() != self.head:
-                    ok = False
+                if target_head is not element.get_head():
+                    return
+                # If the expression is uniform, no further checks are necessary.
+                if is_uniform:
                     break
-            if ok:
-                yield_func(vars_dict, None)
-        else:
-            yield_func(vars_dict, None)
+
+        # Match!
+        vars_dict = pattern_context["vars_dict"]
+        yield_func = pattern_context["yield_func"]
+        yield_func(vars_dict, None)
 
     @property
     def element_order(self) -> tuple:
@@ -240,21 +251,29 @@ class BlankSequence(_Blank):
     summary_text = "match to a non-empty sequence of elements"
 
     def match(self, expression: Expression, pattern_context: dict):
-        vars_dict = pattern_context["vars_dict"]
-        yield_func = pattern_context["yield_func"]
         elements = expression.get_sequence()
+
         if not elements:
             return
-        if self.head:
-            ok = True
+
+        target_head = self.target_head
+        if target_head:
+            is_uniform = False
+            if isinstance(expression, Expression):
+                element_properties = expression.elements_properties
+                if element_properties is not None:
+                    is_uniform = element_properties.is_uniform
             for element in elements:
-                if element.get_head() != self.head:
-                    ok = False
+                if target_head is not element.get_head():
+                    return
+                # If the expression is uniform, no further checks are necessary.
+                if is_uniform:
                     break
-            if ok:
-                yield_func(vars_dict, None)
-        else:
-            yield_func(vars_dict, None)
+
+        # Match!
+        vars_dict = pattern_context["vars_dict"]
+        yield_func = pattern_context["yield_func"]
+        yield_func(vars_dict, None)
 
     def get_match_count(self, vars_dict: OptionalType[dict] = None) -> tuple:
         return (1, None)

mathics/builtin/procedural.py

@@ -309,7 +309,7 @@ class Do(IterationFunction):
     allow_loopcontrol = True
     summary_text = "evaluate an expression looping over a variable"
 
-    def get_result(self, _items):
+    def get_result(self, _items, is_uniform=False):
         return SymbolNull
 
 

mathics/core/builtin.py

@@ -1023,7 +1023,7 @@ class IterationFunction(Builtin, ABC):
     allow_loopcontrol = False
     throw_iterb = True
 
-    def get_result(self, elements) -> Expression:
+    def get_result(self, elements, is_uniform=False) -> Expression:
         raise NotImplementedError
 
     def eval_symbol(self, expr, iterator, evaluation):
@@ -1159,6 +1159,8 @@ def eval_iter(self, expr, i, imin, imax, di, evaluation):
         ).evaluate(evaluation)
 
         result = []
+        last_head = None
+        is_uniform = True
         while True:
             cont = Expression(SymbolLessEqual, index, normalised_range).evaluate(
                 evaluation
@@ -1186,6 +1188,10 @@ def eval_iter(self, expr, i, imin, imax, di, evaluation):
                     evaluation,
                 )
                 result.append(item)
+                if last_head is None:
+                    last_head = item.get_head()
+                elif is_uniform and last_head is not item.get_head():
+                    is_uniform = False
             except ContinueInterrupt:
                 if self.allow_loopcontrol:
                     pass
@@ -1202,7 +1208,7 @@ def eval_iter(self, expr, i, imin, imax, di, evaluation):
                 else:
                     raise
             index = Expression(SymbolPlus, index, Integer1).evaluate(evaluation)
-        return self.get_result(result)
+        return self.get_result(result, is_uniform=is_uniform)
 
     def eval_list(self, expr, i, items, evaluation):
         "%(name)s[expr_, {i_Symbol, {items___}}]"

mathics/core/expression.py

@@ -1956,21 +1956,23 @@ def construct(elements):
 
 # Note: this function is called a *lot* so it needs to be fast.
 def convert_expression_elements(
-    elements: Iterable, conversion_fn: Callable = from_python
+    elements: Iterable, conversion_fn: Callable = from_python, is_uniform: bool = True
 ) -> Tuple[tuple, ElementsProperties, Optional[tuple]]:
     """
     Convert and return tuple of Elements from the Python-like items in
     `elements`, along with elements properties of the elements tuple,
     and a tuple of literal values if it elements are all literal
     otherwise, None.
+    By default, is is assumed that `elements` are *uniform*, which is the typical case
+    of elements coming from applying a numerical function to a set of different arguments.
 
     The return information is suitable for use to the Expression() constructor.
 
     """
 
     # All of the properties start out optimistic (True) and are reset when that
     # proves wrong.
-    elements_properties = ElementsProperties(True, True, True)
+    elements_properties = ElementsProperties(True, True, True, is_uniform)
 
     is_literal = True
     values = []  # If is_literal, "values" contains the (Python) literal values

mathics/eval/parts.py

@@ -167,8 +167,9 @@ def walk_levels(
 
         # FIXME: we could keep track of elements properties here.
         elements = []
+        elem_prop = expr.elements_properties
         for index, element in enumerate(expr.elements):
-            element, element_depth = walk_levels(
+            new_element, element_depth = walk_levels(
                 element,
                 start,
                 stop,
@@ -179,8 +180,11 @@ def walk_levels(
                 cur_pos + [index + 1],
             )
             depth = max(element_depth + 1, depth)
-            elements.append(element)
-        new_expr = make_expression(head, *elements)
+            elements.append(new_element)
+            if new_element is not element:
+                elem_prop = None
+
+        new_expr = make_expression(head, *elements, elements_properties=elem_prop)
 
     if is_in_level(current, depth, start, stop):
         if include_pos:

test/timings/test_uniform_tables.py

@@ -10,8 +10,8 @@
     table_non_uniform_expr = session.evaluate(
         "nonuniformTable=Table[If[i==0,1,1./(1.+i^2)],{i, 0,1000}]"
     )
-    # assert table_uniform_expr.elements_properties.is_uniform
-    # assert not table_non_uniform_expr.elements_properties.is_uniform
+    assert table_uniform_expr.elements_properties.is_uniform
+    assert not table_non_uniform_expr.elements_properties.is_uniform
 
 
 @pytest.mark.skipif(