**Block Inputs:** Two scalar inputs labeled “l” (for
*x*_{1}) and “r” (for *x*_{2}).

The == block is useful for evaluating the Boolean == equality. The output of the == block is 1 if and only if input “l” is identically equal to input “r;” otherwise, the output is 0.

If you right-click the == block, the Boolean block menu appears allowing you to assign a different function to the block.

**Boolean equality comparisons of floating-point variables
and non-integer constants:** As with programming in any language, it is
generally not a good idea to perform Boolean equality comparisons involving
floating-point variables and no-integer constants. These types of comparisons
should be converted to Boolean inequality comparisons. For example, {If position
is equal to π, then …} should be converted to {If position is greater than or
equal to < πroundedoff>, then …}. The reason for this is because a
floating-point variable, such as position, is rarely exactly equal to a
non-zero, non-integer value, particularly if it is obtained by solving one or
more equations.

**1. Comparing constants**

Consider a variable *y* such that:

If* x *= 0.5 then *y* = *cos*( 2*t* );
else *y* = 0

where *t *is simulation time. Let *x* be a step
function of amplitude 0.5, delayed by 3s. This is usually represented as 0.5
*u*(*t *- 3). This system can be realized as shown below.

Until the onset of the step input at *t* = 3s, the
Boolean equality x == 0.5 evaluates to false, and *y* takes on a value of
0. At *t* = 3s, the Boolean equality evaluates to true, and remains true
for the duration of the simulation. Consequently, from this point onwards,
*y* takes on the value of cos(2*t*). The lower plot block is used to
monitor the outputs of the cos block and the variable *x*.

**2. Comparing a floating-point variable with a
non-integer constant**

In a collision detection problem, if position *x* of a
mass in motion is equal to π, then a collision is assumed to have occurred with
an immovable wall that is located at *x* = π. Furthermore, the
position of the mass is assumed to be given by the solution of the following
first order differential equation:

The initial condition is assumed to be *x*(0) = 3.0.
It is tempting to realize this system as:

From the result shown in the plot block, at around *t*
= 7s, the mass arrives at the boundary located at π. However, the collision
detection logic, using an == block that compares *x* with a constant value
of π, never detects the collision. This is because the final mass position, as
obtained from the output of the integrator, is 3.141592653, which is not equal
to 3.14159.

It is clear from the plot block, that for all practical
purposes, the mass collided with the wall around* t* = 7s. To capture this
reality in the simulation, convert the Boolean equality comparison:

If* x* = 3.14159

Then to a Boolean inequality comparison:

If *x* ≥ 3.1415

Then after reducing the const block to four decimal places with no round-off, the system can be realized as:

Except for replacing the == block with the >=
block, this diagram is like the previous one. In this case, the collision
detection logic detects a collision around * t* = 8s.
Obviously, the time at which the collision is detected depends on the number of
decimal places retained for the π approximation.