1.11: Logical Operators

Relational operators allow us to ask one question, such as 'Is x greater than 0?' Logical operators allow us to combine multiple true/false questions into one larger condition. This is extremely useful because real programs often need to check more than one requirement at a time.

The main logical operators in MATLAB are AND, OR, NOT, and exclusive OR. In MATLAB code, these are written using symbols or functions:

Operator or function	Meaning	Returns true when...
a & b or and(a,b)	AND	both a and b are true
a | b or or(a,b)	OR	a is true, b is true, or both are true
~a or not(a)	NOT	a is false
xor(a,b)	Exclusive OR	exactly one of a or b is true, but not both

 

AND (&): returns true only when both conditions are true. If either condition is false, the combined result is false.

 

Example \(\PageIndex{1}\)

Suppose a valid quiz score must be between 0 and 10, inclusive. A score is valid only if it satisfies both requirements: it must be greater than or equal to 0, and it must be less than or equal to 10.

quiz = 8;
isValid = quiz >= 0 & quiz <= 10

Solution

isValid =

    logical

    1

If quiz is 8, both conditions are true, so isValid is true. If quiz is -2, the first condition is false. If quiz is 14, the second condition is false. In both cases, the AND expression returns false.

 

OR (|): returns true when at least one condition is true. OR is useful when more than one option is acceptable.

 

Example \(\PageIndex{2}\)

suppose a user may enter either 'y' or 'Y' to answer yes:

answer = 'Y';
isYes = answer == 'y' | answer == 'Y'

Solution

isYes =

  logical

   1

The result is true because one of the two comparisons is true. With OR, both conditions do not need to be true; at least one is enough.

 

 

NOT (~): reverses a logical value. If something is true, NOT makes it false. If something is false, NOT makes it true.

Example \(\PageIndex{3}\)

Using NOT:

isReady = false;
notReady = ~isReady

Solution

notReady =

  logical

   1

 

 

The NOT operator is especially helpful when you want to express the opposite of a condition. For example, if isValid is false, then ~isValid is true.

 

Exclusive OR (xor): returns true when exactly one of two conditions is true, but not both. This is less common for beginners than AND and OR, but it is useful when two choices are mutually exclusive.

 

Truth Table

A truth table is used to list all combinations of logical inputs and their resulting outputs in a table format:

 

A	B	~A	A and B	A or B	A xor B
false	false	true	false	false	false
false	true	true	false	true	true
true	false	false	false	true	true
true	true	false	true	true	false

 

Example \(\PageIndex{4}\)

Truth table examples:

cold = true;
night = false;
condition_1 = cold & night
condition_2 = cold | night
condition_3 = ~cold
condition_4 = xor(cold, night)

Solution

condition_1 =

logical

0


condition_2 =

logical

1


condition_3 =

logical

0


condition_4 =

logical

1

 

Note

A helpful way to remember the difference between AND and OR is this: AND is stricter because everything must be true. OR is more flexible because only one condition needs to be true.

 

Combining Relational and Logical Operators

In engineering calculations, logical operators are often combined with relational operators. This allows us to create conditions that describe acceptable ranges, safety limits, or categories of values.

Example \(\PageIndex{5}\)

Combining logical and relational operators. 

temperature = 104;
safeTemp = temperature >= 102 & temperature <= 105

Solution

safeTemp =

logical

1

The expression safeTemp in this example reads naturally as: temperature is greater than or equal to 102 AND temperature is less than or equal to 105. Both parts must be true for safeTemp to be true.

 

Example \(\PageIndex{6}\)

 Combining logical and relational operators. 

age = 19;
hasPermit = true;
canDrive = age >= 18 | hasPermit

Solution

canDrive =

  logical

   1

This expression says a person can drive if the person is at least 18 OR has a permit. Depending on the situation, OR may or may not be the correct operator. The programmer must choose the operator that matches the meaning of the problem.

 

 

Short-Circuit Logical Operators

MATLAB also has short-circuit logical operators: && for AND and || for OR. Short-circuit evaluation means MATLAB may skip checking the second condition if the final result can already be determined from the first condition.

For example, in an AND expression, if the first condition is false, the final result must be false. MATLAB does not need to check the second condition. In an OR expression, if the first condition is true, the final result must be true, so MATLAB does not need to check the second condition.

 

Example \(\PageIndex{7}\)

 Using sort-circuit operators. 

x = -5;
isPositiveAndSmall = x > 0 && x < 10
isNegativeOrZero = x < 0 || x == 0

Solution

isPositiveAndSmall =

  logical

   0


isNegativeOrZero =

  logical

   1

 

Note

Beginner guideline: use && and || when combining single true/false conditions in if statements. Use & and | when working element-by-element with arrays. Later, when we study arrays and logical indexing, this distinction becomes very important.

 

Precedence Rules for Logical Operators

Logical expressions also follow precedence rules. Parentheses are evaluated first, then NOT (~), then AND (&), and finally OR (|). Just as with numeric expressions, relying too much on precedence can make code harder to read.

Order	Operator
1	Parentheses ( )
2	NOT ~
3	AND &
4	OR |
5	Left to right for operators of equal precedence

 

Example \(\PageIndex{8}\)

Precedence rules. 

cold = true;
night = false;
raining = true;

result1 = cold | night & raining
result2 = (cold | night) & raining

Solution

result1 =

    logical

    1


result2 =

    logical

    1

In result1, MATLAB evaluates night & raining first because AND has higher precedence than OR. Then it combines the result with cold using OR. In result2, the parentheses force MATLAB to evaluate cold | night first. These two expressions may produce different results depending on the values of the variables.

 

Note

Readability tip: when combining more than two logical conditions, use parentheses even when they are not strictly required. Parentheses make your logic easier to check and reduce the chance of a hidden mistake.

 

A clear expression is better than a clever expression. For example, the following expression is easy to read:

isValidDiameter = (diameter > 0) && (diameter <= 10);

 

The parentheses show exactly what two conditions are being combined. This style is especially helpful when your code is read later by classmates, teammates, or your future self.