# Conditionals#

## IfElse vs Switch#

• Both ops build a condition over symbolic variables.

• `IfElse` takes a boolean condition and two variables as inputs.

• `Switch` takes a tensor as condition and two variables as inputs. `switch` is an elementwise operation and is thus more general than `ifelse`.

• Whereas `switch` evaluates both output variables, `ifelse` is lazy and only evaluates one variable with respect to the condition.

Example

```from aesara import tensor as at
from aesara.ifelse import ifelse
import aesara, time, numpy

a,b = at.scalars('a', 'b')
x,y = at.matrices('x', 'y')

z_switch = at.switch(at.lt(a, b), at.mean(x), at.mean(y))
z_lazy = ifelse(at.lt(a, b), at.mean(x), at.mean(y))

f_switch = aesara.function([a, b, x, y], z_switch,
f_lazyifelse = aesara.function([a, b, x, y], z_lazy,

val1 = 0.
val2 = 1.
big_mat1 = numpy.ones((10000, 1000))
big_mat2 = numpy.ones((10000, 1000))

n_times = 10

tic = time.perf_counter()
for i in range(n_times):
f_switch(val1, val2, big_mat1, big_mat2)
print('time spent evaluating both values %f sec' % (time.perf_counter() - tic))

tic = time.perf_counter()
for i in range(n_times):
f_lazyifelse(val1, val2, big_mat1, big_mat2)
print('time spent evaluating one value %f sec' % (time.perf_counter() - tic))
```

In this example, the `IfElse` op spends less time (about half as much) than `Switch` since it computes only one variable out of the two.

```\$ python ifelse_switch.py
time spent evaluating both values 0.6700 sec
time spent evaluating one value 0.3500 sec
```

Unless `linker='vm'` or `linker='cvm'` are used, `ifelse` will compute both variables and take the same computation time as `switch`. Although the linker is not currently set by default to `cvm`, it will be in the near future.

There is no automatic rewrite replacing a `switch` with a broadcasted scalar to an `ifelse`, as this is not always faster. See this ticket.

Note

If you use test values, then all branches of the IfElse will be computed. This is normal, as using test_value means everything will be computed when we build it, due to Python’s greedy evaluation and the semantic of test value. As we build both branches, they will be executed for test values. This doesn’t cause any changes during the execution of the compiled Aesara function.