Logical operators (&, |, ~) in MATLAB - Deep Dive

Overview - Logical operators (&, |, ~)

What is it?

Logical operators in MATLAB are symbols used to combine or modify true and false values. The operator & means AND, which is true only if both parts are true. The operator | means OR, which is true if at least one part is true. The operator ~ means NOT, which flips true to false and false to true.

Why it matters

Logical operators let us make decisions and filter data based on conditions. Without them, computers couldn't choose between options or find specific information in data. They are the foundation of all decision-making in programming and data analysis.

Where it fits

Before learning logical operators, you should understand basic data types like true/false (logical values) and how to write simple expressions. After mastering logical operators, you can learn about conditional statements, loops, and complex data filtering.

Mental Model

Core Idea

Logical operators combine or invert true/false values to help computers make decisions.

Think of it like...

Think of logical operators like traffic lights: AND (&) is like needing both green lights to go, OR (|) is like having at least one green light to go, and NOT (~) is like a red light that stops you when you expected to go.

Truth Table for AND (&):
A | B | A & B
--+---+-------
0 | 0 |   0
0 | 1 |   0
1 | 0 |   0
1 | 1 |   1

Truth Table for OR (|):
A | B | A | B
--+---+-------
0 | 0 |   0
0 | 1 |   1
1 | 0 |   1
1 | 1 |   1

Truth Table for NOT (~):
A | ~A
--+---
0 | 1
1 | 0

Build-Up - 6 Steps

1

Foundation

Understanding Logical Values in MATLAB

Concept: Learn what true and false mean in MATLAB and how they are represented.

In MATLAB, logical values are represented as 1 (true) and 0 (false). You can create logical variables by comparing numbers or expressions. For example, 5 > 3 returns true (1), and 2 == 4 returns false (0). These logical values are the building blocks for using logical operators.

Result

You can create and see logical values like 1 (true) and 0 (false) in MATLAB.

Understanding that MATLAB uses 1 and 0 for true and false helps you see how logical operators work on these values.

2

Foundation

Basic Use of Logical Operators & | ~

Concept: Learn how to use AND (&), OR (|), and NOT (~) operators with logical values.

The AND operator (&) returns true only if both inputs are true. The OR operator (|) returns true if at least one input is true. The NOT operator (~) flips true to false and false to true. For example, true & false returns false, true | false returns true, and ~true returns false.

Result

You can combine logical values to get new true or false results using & | ~.

Knowing how these operators combine or invert logical values lets you build complex conditions.

3

Intermediate

Applying Logical Operators to Arrays

🤔Before reading on: Do you think logical operators work element-wise on arrays or on the whole array at once? Commit to your answer.

Concept: Logical operators in MATLAB work element-wise on arrays, comparing each element separately.

If you have two arrays of the same size, like A = [1 0 1] and B = [0 1 1], then A & B returns [0 0 1] because it applies AND to each pair of elements. Similarly, A | B returns [1 1 1], and ~A returns [0 1 0]. This lets you filter or compare data element by element.

Result

Logical operators produce new arrays of true/false values by comparing each element.

Understanding element-wise operation is key to using logical operators for data filtering and analysis.

4

Intermediate

Combining Multiple Logical Conditions

🤔Before reading on: When combining multiple conditions with & and |, do you think MATLAB evaluates them left to right or follows a priority order? Commit to your answer.

Concept: MATLAB follows operator precedence: NOT (~) first, then AND (&), then OR (|). Parentheses can change this order.

You can combine conditions like (A > 0) & (B < 5) | (C == 10). MATLAB first evaluates NOT, then AND, then OR. Using parentheses helps control the order. For example, (A > 0) & ((B < 5) | (C == 10)) changes the logic grouping.

Result

You can build complex logical expressions that MATLAB evaluates correctly using precedence and parentheses.

Knowing operator precedence prevents bugs and ensures your conditions mean what you intend.

5

Advanced

Logical Operators vs Short-Circuit Operators

🤔Before reading on: Do you think & and | in MATLAB stop evaluating as soon as the result is known (short-circuit), or do they always evaluate all parts? Commit to your answer.

Concept: In MATLAB, & and | always evaluate all parts; they do not short-circuit. Short-circuit operators are && and ||, used only with scalars.

The & and | operators work element-wise and evaluate every element. The && and || operators are short-circuit and only work with single true/false values (scalars). For example, if you write (x > 0) && (y < 5), MATLAB stops checking if the first is false. But (x > 0) & (y < 5) evaluates both fully.

Result

You understand when to use & | for arrays and && || for scalar short-circuit logic.

Knowing the difference avoids unexpected errors and improves performance in conditional checks.

6

Expert

Logical Operator Behavior with Non-Logical Types

🤔Before reading on: Do you think MATLAB's logical operators only work with logical true/false values, or can they also work with numbers? Commit to your answer.

Concept: MATLAB treats non-zero numbers as true and zero as false when using logical operators, but the output is always logical.

If you use logical operators on numeric arrays, MATLAB converts non-zero values to true and zero to false before applying the operator. For example, [1 2 0] & [0 1 1] returns [false true false] because 1 and 2 are true, 0 is false. The result is a logical array, not numeric.

Result

Logical operators can be applied to numeric arrays, but the result is always logical true/false values.

Understanding implicit conversion helps avoid confusion when mixing numeric and logical data in conditions.

Under the Hood

MATLAB stores logical values as bits (1 or 0) and applies logical operators element-wise using fast bitwise operations. When applied to arrays, MATLAB loops internally over elements or uses vectorized instructions to compute results efficiently. The operators & and | do not short-circuit and always evaluate all operands, while && and || are designed for scalar short-circuit evaluation.

Why designed this way?

MATLAB was designed for matrix and array operations, so logical operators work element-wise to support vectorized code. The separation between & | and && || allows both array-wise logic and efficient scalar condition checks. This design balances performance and flexibility for numerical computing.

Input Arrays A and B
┌─────────────┐   ┌─────────────┐
│ A: [1 0 1] │   │ B: [0 1 1] │
└─────┬───────┘   └─────┬───────┘
      │                 │
      │ Element-wise    │
      │ Logical & / |   │
      ▼                 ▼
┌───────────────────────────┐
│ Result: [A & B] = [0 0 1] │
│ Result: [A | B] = [1 1 1] │
└───────────────────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Do you think & and && behave the same way in MATLAB? Commit to yes or no.

Common Belief: Many believe & and && are interchangeable logical AND operators.

Reality: & is element-wise and works on arrays, while && is short-circuit and only works on scalars.

Why it matters: Using && with arrays causes errors, and using & when short-circuiting is needed can cause inefficient or incorrect code.

Quick: Do you think logical operators return numeric 1 or 0, or logical true/false? Commit to your answer.

Common Belief: Some think logical operators return numeric values like 1 or 0.

Reality: Logical operators always return logical true or false values, not numeric types.

Why it matters: Confusing logical and numeric types can cause bugs when mixing data types or indexing.

Quick: Do you think logical NOT (~) flips all bits in a number or just the logical value? Commit to your answer.

Common Belief: Some believe ~ flips all bits of a number like a bitwise NOT.

Reality: ~ only flips logical true/false values, not the bits of numeric values.

Why it matters: Misunderstanding this leads to wrong results when applying ~ to numeric arrays.

Expert Zone

1

Logical operators & and | always evaluate all elements, which can impact performance in large arrays compared to short-circuit operators.

2

Using parentheses to control operator precedence is critical in complex logical expressions to avoid subtle bugs.

3

MATLAB converts numeric values to logical when using logical operators, but the output is always logical, which can affect downstream calculations.

When NOT to use

Avoid using & and | for scalar conditional checks where short-circuiting is desired; use && and || instead. For bitwise operations on integers, use bitand, bitor, and bitcmp functions rather than logical operators.

Production Patterns

In real-world MATLAB code, logical operators are heavily used for filtering arrays, masking data, and controlling flow in vectorized computations. Experts combine logical indexing with these operators to write concise, efficient data analysis scripts.

Connections

Boolean Algebra

Logical operators in MATLAB implement Boolean algebra rules for true/false logic.

Understanding Boolean algebra helps grasp how logical operators combine conditions and simplify expressions.

Set Theory

Logical AND and OR correspond to set intersection and union operations.

Seeing logical operators as set operations clarifies their behavior when filtering or combining data groups.

Digital Circuit Design

Logical operators mirror gates like AND, OR, and NOT in digital circuits.

Knowing digital logic helps understand how computers physically implement these operations efficiently.

Common Pitfalls

#1 Using & and | with scalar conditions expecting short-circuit behavior.

Wrong approach:

if (x > 0) & (y < 5)
disp('Condition met')
end

Correct approach:

if (x > 0) && (y < 5)
disp('Condition met')
end

Root cause:

Confusing element-wise logical operators with short-circuit operators leads to unexpected evaluation of all conditions.

#2 Applying logical NOT (~) to numeric arrays expecting bitwise inversion.

Wrong approach:

A = [1 2 3];
B = ~A; % expecting bitwise NOT

Correct approach:

A = [1 2 3];
B = bitcmp(uint8(A)); % correct bitwise NOT

Root cause:

Misunderstanding that ~ works on logical values, not bits, causes wrong results.

#3 Mixing numeric and logical types without conversion causing indexing errors.

Wrong approach:

idx = (A > 0) + (B < 5); % numeric sum instead of logical AND/OR

Correct approach:

idx = (A > 0) & (B < 5); % logical AND for indexing

Root cause:

Using arithmetic operators instead of logical operators leads to numeric results, not logical masks.

Key Takeaways

Logical operators & (AND), | (OR), and ~ (NOT) combine or invert true/false values to build conditions.

In MATLAB, these operators work element-wise on arrays, enabling powerful data filtering and analysis.

Operator precedence and parentheses control how complex logical expressions are evaluated.

& and | always evaluate all parts; use && and || for scalar short-circuit logic.

Understanding how MATLAB treats numeric and logical types prevents common bugs in logical operations.