5. Boolean expressions and conditionals

5.1. Relationals

In addition to scalar-valued expressions, we can also construct boolean-valued expressions using relationals:

>>> x, y = sym.symbols('x, y')
>>> condition = x < y
>>> type(condition)
pywrenfold.sym.BooleanExpr
>>> print(condition.expression_tree_str())

Relational (<)
├─ Variable (x, unknown)
└─ Variable (y, unknown)

Warning

The __eq__ method in python corresponds to strict equality, not mathematical equivalence. Hence the == operator will directly return True if the two expression trees are completely identical, and False otherwise. To construct an equivalence relational, use wrenfold.sym.eq() instead.

>>> x == y
False
>>> sym.eq(x, y)
x == y

5.2. Conditional logic

Boolean-valued expressions are relevant when creating conditional expressions. A ternary conditional can be constructed using wrenfold.sym.where():

>>> f = sym.where(x > 0, x * y, -x / 5)
>>> f
where(0 < x, x*y, -x/5)  # Note that `x > 0` was canonicalized as `0 < x`.

In the example above, \(f\left(x\right)\) is a piecewise function with a discontinuity in the first derivative at \(x = 0\). At code-generation time, sym.where will be converted to an if-else branch. This can serve a number of purposes:

  • Skipping irrelevant computations.

  • Avoiding singularities or calculations that would introduce NaN values.

  • Implementing piecewise continuous functions.

The result of the conditional is a scalar-valued expression, so it can be differentiated:

# Take the derivative of both branches.
>>> f.diff(x)
where(0 < x, y, -1/5)
# Take the derivative of both branches, twice.
# Since both sides evaluate to zero, the conditional is immediately simplified:
>>> f.diff(x, 2)
0

Note

When taking the derivative of sym.where expressions, the contribution of the condition itself is ignored and the two branches are differentiated to create a new piecewise function. In the example above, the true derivative of the function \(f\left(x\right)\) is infinite at \(x = 0\). We could insert the Dirac delta function to capture this, but this result would not be very useful in a numerical evaluation context.

5.3. Casting booleans

Boolean expressions cannot be multiplied or added like scalars, but they can be “casted” to scalars using the Iverson bracket. The iverson bracket evaluates to 1 if the boolean condition is true, and 0 if the condition is false.

>>> condition = x < y
>>> g = sym.iverson(condition)
>>> g
iverson(x < y)
# Substitute values that make the statement true:
>>> g.subs(x, 0.23).subs(y, 4)
1

This can be useful if you want to mask out a value without inserting a conditional:

# We can't multiply (x < 0) by sin(x) directly, but we can do this:
>>> h = sym.iverson(x < 0) * sym.sin(x)
>>> h
sin(x)*iverson(x < 0)
# Will be zero for all positive `x`:
>>> h.subs(x, 0.7)
0