# ufl.corealg package

## Submodules

## ufl.corealg.dag_traverser module

Base class for dag traversers.

class ufl.corealg.dag_traverser.DAGTraverser(compress: bool | None = True, visited_cache: dict[tuple, Expr] | None = None, result_cache: dict[Expr, Expr] | None = None)

  Bases: `object`

  Base class for DAG traversers.

  Args:

    compress: If True, `result_cache` will be used. visited_cache: cache of intermediate results; expr -> r = self.process(expr, …). result_cache: cache of result objects for memory reuse, r -> r.

  static postorder(method)

    Postorder decorator.

    It is more natural for users to write a post-order singledispatchmethod whose arguments are `(self, o, *processed_operands, **kwargs)`, while DAGTraverser expects one whose arguments are `(self, o, **kwargs)`. This decorator takes the former and converts to the latter, processing `o.ufl_operands` behind the users.

  static postorder_only_children(indices)

    Postorder decorator with child indices.

    This decorator is the same as DAGTraverser.postorder except that the decorated method is only to take processed operands corresponding to `indices`.

  process(o: Expr, **kwargs) → Expr

    Process node by type.

    Args:

      o: Expr to start DAG traversal from. **kwargs: keyword arguments for the `process` singledispatchmethod.

    Returns:

      Processed Expr.

  reuse_if_untouched(o: Expr, **kwargs) → Expr
  reuse_if_untouched(o: BaseForm, **kwargs) → BaseForm

    Reuse if touched.

    Args:

      o: Expr to start DAG traversal from. **kwargs: keyword arguments for the `process` singledispatchmethod.

    Returns:

      Processed Expr.

## ufl.corealg.map_dag module

Basic algorithms for applying functions to subexpressions.

ufl.corealg.map_dag.map_expr_dag(function, expression, compress=True, vcache=None, rcache=None)

  Apply a function to each subexpression node in an expression DAG.

  If the same function is called multiple times in a transformation (as for example in apply_derivatives), then to reuse caches across the call, use the arguments vcache and rcache.

  Args:
    function:

      The function

    expression:

      An expression

    compress: If True (default), the output object from

      the function is cached in a dict and reused such that the resulting expression DAG does not contain duplicate objects

    vcache: Optional dict for caching results of intermediate

      transformations

    rcache: Optional dict for caching results for compression

  Returns:

    The result of the final function call

ufl.corealg.map_dag.map_expr_dags(function, expressions, compress=True, vcache=None, rcache=None)

  Apply a function to each sub-expression node in an expression DAG.

  If compress is `True` (default) the output object from the function is cached in a `dict` and reused such that the resulting expression DAG does not contain duplicate objects.

  If the same function is called multiple times in a transformation (as for example in apply_derivatives), then to reuse caches across the call, use the arguments vcache and rcache.

  Args:
    function:

      The function

    expressions:

      An expression

    compress:

      If True (default), the output object from the function is cached in a dict and reused such that the resulting expression DAG does not contain duplicate objects

    vcache:

      Optional dict for caching results of intermediate transformations

    rcache:

      Optional dict for caching results for compression

  Returns:

    a list with the result of the final function call for each expression

## ufl.corealg.multifunction module

Base class for multifunctions with UFL `Expr` type dispatch.

class ufl.corealg.multifunction.MultiFunction

  Bases: `object`

  Base class for collections of non-recursive expression node handlers.

  Subclass this (remember to call the `__init__` method of this class), and implement handler functions for each `Expr` type, using the lower case handler name of the type (`exprtype._ufl_handler_name_`).

  This class is optimized for efficient type based dispatch in the `__call__` operator via typecode based lookup of the handler function bound to the algorithm object. Of course Python’s function call overhead still applies.

  reuse_if_untouched(o, *ops)

    Reuse object if operands are the same objects.

    Use in your own subclass by setting e.g.

        expr = MultiFunction.reuse_if_untouched

    as a default rule.

  ufl_type(o, *args)

    Trigger error for types with missing handlers.

  undefined(o, *args)

    Trigger error for types with missing handlers.

ufl.corealg.multifunction.get_num_args(function)

  Return the number of arguments accepted by function.

ufl.corealg.multifunction.memoized_handler(handler)

  Function decorator to memoize `MultiFunction` handlers.

## ufl.corealg.traversal module

Various expression traversal utilities.

The algorithms here are non-recursive, which is faster than recursion by a factor of 10 or so because of the function call overhead.

ufl.corealg.traversal.cutoff_post_traversal(expr, cutofftypes)

  Cut-off post-tranversal.

  Yield `o` for each node `o` in expr, child before parent, but skipping subtrees of the cutofftypes.

ufl.corealg.traversal.cutoff_unique_post_traversal(expr, cutofftypes, visited=None)

  Yield `o` for each node `o` in expr, child before parent.

  Never visit a node twice.

ufl.corealg.traversal.post_traversal(expr)

  Yield `o` for each node `o` in expr, child before parent.

ufl.corealg.traversal.pre_traversal(expr)

  Yield `o` for each tree node `o` in expr, parent before child.

ufl.corealg.traversal.traverse_terminals(expr)

  Traverse terminals.

ufl.corealg.traversal.traverse_unique_terminals(expr, visited=None)

  Traverse unique terminals.

ufl.corealg.traversal.unique_post_traversal(expr, visited=None)

  Yield `o` for each node `o` in expr, child before parent.

  Never visit a node twice.

ufl.corealg.traversal.unique_pre_traversal(expr, visited=None)

  Yield `o` for each tree node `o` in expr, parent before child.

  This version only visits each node once.

## Module contents

Core algorithms.