# ufl.corealg package¶

## ufl.corealg.map_dag module¶

Basic algorithms for applying functions to subexpressions.

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

Apply a function to each subexpression 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.

Return the result of the final function call.

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

Apply a function to each subexpression 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.

Return 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.

expr(o, *args)

Trigger error for types with missing handlers.

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.

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)

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)

Iterate over all terminal objects in expr, including duplicates.

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

Iterate over all terminal objects in expr, not including duplicates.

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.