Logical Expressions and Relational Operators

Understanding Logical Expressions

Logical expressions in MATLAB are expressions that evaluate to a logical value, either true or false. Internally, MATLAB represents true as 1 and false as 0, but it treats them as a separate logical data type.

The result of a logical expression can be stored in a variable, used directly in the Command Window, or passed into control flow statements such as if and while. For example, the expression 5 > 3 returns a logical 1, which MATLAB displays as 1 but understands as true in conditions.

You can see the class of a logical value using class. For example, class(5 > 3) returns 'logical'. Logical arrays behave like numeric arrays in some contexts, but they have specific uses such as indexing and controlling execution.

Relational Operators

Relational operators compare values and produce logical results. They are used between scalars, vectors, matrices, or any array of compatible sizes. The key relational operators in MATLAB are equality, inequality, and ordering comparisons.

The equality operator == checks whether two values are equal. For example, 3 == 3 gives 1, and 3 == 4 gives 0. The inequality operator ~= checks whether two values are not equal. For instance, 3 ~= 4 gives 1, while 3 ~= 3 gives 0.

Ordering comparisons use <, >, <=, and >=. For example, 2 < 5 evaluates to true, while 7 >= 7 is also true. When you write something like x <= 10, MATLAB checks each element of x against 10 and returns a logical array of the same size.

Relational operators are vectorized, so when applied to arrays of the same size, they compare elements pairwise. Writing A == B where A and B are matrices of equal size returns a logical matrix where each element is true if and only if the corresponding elements of A and B are equal.

If you compare arrays with a scalar, MATLAB compares the scalar to every element of the array. For example, if A is a vector, then A > 0 gives a logical vector that indicates which elements are greater than zero.

Basic Logical Operators

Logical operators combine or modify logical values and logical arrays. The most common logical operators are &, |, ~, and the short-circuit forms && and ||.

The operator & represents logical AND. It returns true only when both operands are true. For example, (5 > 3) & (2 < 4) evaluates to true. When used with arrays of the same size, & operates element by element. For instance, if A > 0 and A < 10 each return a logical vector, then (A > 0) & (A < 10) combines the conditions elementwise.

The operator | represents logical OR. It returns true when at least one of the operands is true. For example, (5 > 3) | (2 > 4) is true. With arrays of the same size, it also works elementwise, combining corresponding elements.

The operator ~ is logical NOT. It takes a single logical operand and flips its value. If x is true, then ~x is false, and if x is false, then ~x is true. When applied to a logical array, ~A returns an array where each element is the opposite of the corresponding element in A.

Because logical operators are typically used with relational expressions, you often see them combined, such as (x > 0) & (x < 1) or ~(x == 0).

Short-Circuit Operators in Conditions

MATLAB has short-circuit logical operators && and || that you will typically use in conditions inside if and while statements. These operators only work with scalar logical values, not with arrays.

The short-circuit AND operator && evaluates its second operand only if the first operand is true. For example, in (x ~= 0) && (y / x > 1), MATLAB first evaluates x ~= 0. If x is zero, the first part is false, and MATLAB does not evaluate y / x > 1. This behavior can be useful to avoid operations that would produce an error or are unnecessary.

The short-circuit OR operator || evaluates its second operand only if the first operand is false. For instance, (x > 10) || (y > 5) first checks if x > 10. If this is true, MATLAB does not evaluate y > 5, because the entire expression is already true.

In contrast, the operators & and | do not short-circuit. They always evaluate both sides and can operate on arrays. For this reason, you should use && and || with scalar logical values in control flow, and use & and | when you work with logical arrays.

Operator Precedence and Grouping

When you combine relational and logical operators in one expression, MATLAB follows a specific order of evaluation called operator precedence. Relational operators such as <, >, <=, >=, ==, and ~= are evaluated after arithmetic operations but before most logical operators.

Within logical operators, MATLAB evaluates NOT ~ first, then elementwise AND &, followed by elementwise OR |. The short-circuit operators && and || have their own precedence in scalar conditions. This order means that the expression ~a & b == c | d is not interpreted as you might expect at first glance.

To make your intentions clear and to avoid subtle bugs, you should use parentheses to group conditions explicitly. For example, instead of relying on precedence, write something like (~a) & (b == c) | d or better, ((~a) & (b == c)) | d, or any grouping that matches the logic you want. Parentheses make the code easier to read and reduce the chance of misinterpretation by someone reading your code later, including yourself.

Logical Arrays and Their Use in Conditions

Logical expressions applied to arrays produce logical arrays. Each element of the result indicates whether the corresponding element of the original array satisfies the condition.

Although you will use logical arrays for indexing in another chapter, they also interact with conditions in simple ways. Some functions, such as all and any, reduce a logical array to a single logical value. For example, all(A > 0) returns true if every element of A is greater than zero. The function any(A < 0) returns true if at least one element of A is less than zero.

These reduction functions are often used to create scalar logical values suitable for if or while, starting from an array condition. For instance, you might check whether all values meet a threshold using if all(x >= limit), which is a compact way to test the entire array.

When you write a condition directly using an array without reducing it, MATLAB requires that the result be a scalar logical. If it is not, MATLAB produces an error in control flow constructs. Using functions like any or all is the usual way to bridge between array conditions and scalar logicals.

Comparing Floating Point Numbers

Relational operators work straightforwardly with integers, but you must be careful when comparing floating point numbers. Due to the way they are represented, results of computations such as 0.1 + 0.2 may not be stored as an exact decimal value.

As a consequence, direct equality tests like a == b can give unexpected results when a and b are computed from floating point operations. Instead of checking for exact equality, you often compare the absolute difference against a small tolerance. For example, you could write abs(a - b) < 1e-10 to test whether a and b are equal to within a tiny margin.

This pattern still uses relational operators, but it acknowledges that floating point computations may produce small numerical errors. For beginners, it is enough to understand that exact equality with floating point results is sometimes unreliable, and tolerance based comparisons are safer when the values come from calculations rather than from exact constants.

Common Patterns in Logical Conditions

Logical expressions and relational operators often appear in common patterns. One such pattern is checking that a value lies within a range. For instance, x >= 0 & x <= 1 creates a logical array that is true where x lies between 0 and 1 inclusive. In a scalar context, the same expression forms a compound condition.

Another frequent pattern is combining an equality test with additional constraints. For example, (n == round(n)) & (n > 0) evaluates to true where n is both positive and an integer value. You can further refine such expressions by nesting additional logical operators as needed.

Negation also appears in common patterns. Instead of writing x ~= 0, you could write ~(x == 0). While these are equivalent, it is usually clearer to use the direct inequality operator when it exists. Reserve more complex negated expressions for cases where you invert an entire combined condition, such as ~(x > 0 & y > 0).

These patterns are primarily used to prepare conditions for control flow constructs. In this chapter, it is enough to see how to build logical expressions properly. You will later see how these expressions control execution of if, elseif, else, and loops.