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)[source]¶
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)[source]¶
Postorder decorator.
It is more natural for users to write a post-order singledispatchmethod whose arguments are
(self, o, *processed_operands, *additional_args)
, while DAGTraverser expects one whose arguments are(self, o, *additional_args)
. This decorator takes the former and converts the latter, processingo.ufl_operands
behind the users.
- static postorder_only_children(indices)[source]¶
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
.
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)[source]¶
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)[source]¶
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 adict
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[source]¶
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 eachExpr
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)[source]¶
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.
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)[source]¶
Cut-off post-tranversal.
Yield
o
for each nodeo
in expr, child before parent, but skipping subtrees of the cutofftypes.
- ufl.corealg.traversal.cutoff_unique_post_traversal(expr, cutofftypes, visited=None)[source]¶
Yield
o
for each nodeo
in expr, child before parent.Never visit a node twice.
- ufl.corealg.traversal.post_traversal(expr)[source]¶
Yield
o
for each nodeo
in expr, child before parent.
- ufl.corealg.traversal.pre_traversal(expr)[source]¶
Yield
o
for each tree nodeo
in expr, parent before child.
- ufl.corealg.traversal.traverse_unique_terminals(expr, visited=None)[source]¶
Traverse unique terminals.
Module contents¶
Core algorithms.