pymor.analyticalproblems.expressions

This module contains a basic symbolic expression library.

The library is used by ExpressionFunction and ExpressionParameterFunctional by calling parse_expression, which parses str expressions by replacing the names in the string with objects from this module. The result is an Expression object, which can be converted to a NumPy-vectorized function using Expression.to_numpy. In the future, more conversion routines will be added to make the same Expression usable for pymor.discretizers that use external PDE solvers. Further advantages of using this expression library:

• meaningful error messages are generated at parse time of the str expression, instead of hard-to-debug errors in lambda functions at evaluation time,

• expressions are automatically correctly vectorized. In particular, there is no longer a need to add ... to indexing expressions,

• the shape of the resulting expressions is automatically determined.

In the future, we will also provide support for symbolic differentiation of the given Expressions.

Every Expression is built from the following atoms:

• a Constant, which is a fixed value of arbitrary shape,

• a Parameter, which is a variable of a fixed one-dimensional shape.

Note that both Parameters and input variables are treated as a Parameter in the expression. Only when calling, e.g., to_numpy, it is determined which Parameter belongs to the resulting function’s Parameters and which Parameter is treated as an input variable.

More complex expressions can be built using:

• binary operators,

• negation,

• function calls,

• indexing,

• array construction.

For binary operations of Expressions of different shape, the usual broadcasting rules apply.

Module Contents

pymor.analyticalproblems.expressions.builtin_max

pymor.analyticalproblems.expressions.e

pymor.analyticalproblems.expressions.pi

class pymor.analyticalproblems.expressions.Array(array)

Bases: Expression

An array of scalar-valued Expressions.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.BaseConstant

Bases: Expression

A constant value.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_symbol

numpy_symbol

shape = []

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.BinaryOp(first, second)

Bases: Expression

Compound Expression of a binary operator acting on two sub-expressions.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_symbol

numpy_symbol

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.Constant(value)

Bases: BaseConstant

A constant value given by a NumPy array.

Methods

fenics_expr

Called by to_fenics.

shape = []

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.Diff(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol

numpy_symbol = -

class pymor.analyticalproblems.expressions.Div(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol

numpy_symbol = /

class pymor.analyticalproblems.expressions.E

Bases: BaseConstant

A constant value.

fenics_symbol = e

numpy_symbol = e

class pymor.analyticalproblems.expressions.Expression

Bases: pymor.parameters.base.ParametricObject

A symbolic math expression

shape

The shape of the object this expression evaluates to in the sense of NumPy.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.
to_fenics
to_numpy	Convert expression to a NumPy-vectorized callable.

abstract fenics_expr(params)

Called by to_fenics.

abstract numpy_expr()

Called by to_numpy.

to_fenics(mesh, variable='x')

to_numpy(variables)

Convert expression to a NumPy-vectorized callable.

Parameters

variables

List of names of ~Parameters in the expression which shall be treated as input variables.

class pymor.analyticalproblems.expressions.GE(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol = ge

numpy_symbol = >=

class pymor.analyticalproblems.expressions.GT(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol = gt

numpy_symbol = >

class pymor.analyticalproblems.expressions.Indexed(base, index)

Bases: Expression

Indexed Expression.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.LE(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol = le

numpy_symbol = <=

class pymor.analyticalproblems.expressions.LT(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol = lt

numpy_symbol = <

class pymor.analyticalproblems.expressions.Mod(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol

numpy_symbol = %

class pymor.analyticalproblems.expressions.Neg(operand)

Bases: Expression

Negated Expression.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.Parameter(name, dim)

Bases: Expression

A free parameter in an Expression.

Parameters represent both pyMOR Parameters as well as input variables. Each parameter is a vector of shape (dim,).

Parameters

name

The name of the parameter.

dim

The dimension of the parameter.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.Pi

Bases: BaseConstant

A constant value.

fenics_symbol = pi

numpy_symbol = pi

class pymor.analyticalproblems.expressions.Pow(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol = elem_pow

numpy_symbol = **

class pymor.analyticalproblems.expressions.Prod(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol

numpy_symbol = *

class pymor.analyticalproblems.expressions.Sum(first, second)

Bases: BinaryOp

Compound Expression of a binary operator acting on two sub-expressions.

fenics_symbol

numpy_symbol = +

class pymor.analyticalproblems.expressions.TransformLiterals

Bases: ast.NodeTransformer

A NodeVisitor subclass that walks the abstract syntax tree and allows modification of nodes.

The NodeTransformer will walk the AST and use the return value of the visitor methods to replace or remove the old node. If the return value of the visitor method is None, the node will be removed from its location, otherwise it is replaced with the return value. The return value may be the original node in which case no replacement takes place.

Here is an example transformer that rewrites all occurrences of name lookups (foo) to data['foo']:

class RewriteName(NodeTransformer):

    def visit_Name(self, node):
        return Subscript(
            value=Name(id='data', ctx=Load()),
            slice=Constant(value=node.id),
            ctx=node.ctx
        )

Keep in mind that if the node you’re operating on has child nodes you must either transform the child nodes yourself or call the generic_visit method for the node first.

For nodes that were part of a collection of statements (that applies to all statement nodes), the visitor may also return a list of nodes rather than just a single node.

Usually you use the transformer like this:

node = YourTransformer().visit(node)

Methods

visit_Constant
visit_List
visit_Num
visit_Subscript

in_subscript = False

visit_Constant(node)

visit_List(node)

visit_Num(node)

visit_Subscript(node)

class pymor.analyticalproblems.expressions.UnaryFunctionCall(arg, *args)

Bases: Expression

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_symbol

numpy_symbol

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.UnaryReductionCall(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied to the entire vector/matrix/tensor the sub-expression evaluates to, returning a single number.

Methods

fenics_expr	Called by to_fenics.
numpy_expr	Called by to_numpy.

fenics_op

numpy_symbol

fenics_expr(params)

Called by to_fenics.

numpy_expr()

Called by to_numpy.

class pymor.analyticalproblems.expressions.abs(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = abs

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.angle(arg)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

fenics_op

numpy_symbol = angle

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.arccos(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = acos

numpy_symbol = arccos

class pymor.analyticalproblems.expressions.arccosh(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = arccosh

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.arcsin(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = asin

numpy_symbol = arcsin

class pymor.analyticalproblems.expressions.arcsinh(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = arcsinh

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.arctan(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = atan

numpy_symbol = arctan

class pymor.analyticalproblems.expressions.arctanh(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = arctanh

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.cos(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = cos

numpy_symbol = cos

class pymor.analyticalproblems.expressions.cosh(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = cosh

numpy_symbol = cosh

class pymor.analyticalproblems.expressions.exp(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = exp

numpy_symbol = exp

class pymor.analyticalproblems.expressions.exp2(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = exp2

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.log(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = ln

numpy_symbol = log

class pymor.analyticalproblems.expressions.log10(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = log10

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.log2(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = log2

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.max(arg, *args)

Bases: UnaryReductionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied to the entire vector/matrix/tensor the sub-expression evaluates to, returning a single number.

fenics_op = max_value

numpy_symbol = max

class pymor.analyticalproblems.expressions.min(arg, *args)

Bases: UnaryReductionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied to the entire vector/matrix/tensor the sub-expression evaluates to, returning a single number.

fenics_op = min_value

numpy_symbol = min

class pymor.analyticalproblems.expressions.norm(arg, *args)

Bases: UnaryReductionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied to the entire vector/matrix/tensor the sub-expression evaluates to, returning a single number.

Methods

fenics_expr

Called by to_fenics.

numpy_symbol = norm

fenics_expr(params)

Called by to_fenics.

class pymor.analyticalproblems.expressions.prod(arg, *args)

Bases: UnaryReductionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied to the entire vector/matrix/tensor the sub-expression evaluates to, returning a single number.

fenics_op

numpy_symbol = prod

class pymor.analyticalproblems.expressions.sign(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = sign

numpy_symbol = sign

class pymor.analyticalproblems.expressions.sin(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = sin

numpy_symbol = sin

class pymor.analyticalproblems.expressions.sinh(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = sinh

numpy_symbol = sinh

class pymor.analyticalproblems.expressions.sqrt(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = sqrt

numpy_symbol = sqrt

class pymor.analyticalproblems.expressions.sum(arg, *args)

Bases: UnaryReductionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied to the entire vector/matrix/tensor the sub-expression evaluates to, returning a single number.

fenics_op

numpy_symbol = sum

class pymor.analyticalproblems.expressions.tan(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = tan

numpy_symbol = tan

class pymor.analyticalproblems.expressions.tanh(arg, *args)

Bases: UnaryFunctionCall

Compound Expression of an unary function applied to a sub-expression.

The function is applied component-wise.

fenics_symbol = tanh

numpy_symbol = tanh

pymor.analyticalproblems.expressions.parse_expression(expression, parameters={}, values={})