KAHIBARO Bookshelves
Discord Login Register

5.5. 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.

Important points to remember:
Relational operators such as ==, ~=, <, >, <=, and >= return logical values or logical arrays.
Logical operators &, |, and ~ operate elementwise on logical arrays, while && and || are short-circuit operators for scalar logical conditions.
Use parentheses to group complex logical expressions explicitly, instead of relying on operator precedence.
When comparing results of floating point computations, prefer tolerance based comparisons like abs(a - b) < tol instead of a == b.
Functions such as any and all turn logical arrays into single logical values that are suitable for use in conditions.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Getting Started with MATLAB
    • ☰ 1.1. What Is MATLAB and What Is It Used For
      • ☰ 1.2. Installing MATLAB and Setting Up the Environment
        • ☰ 1.3. Understanding the MATLAB Desktop Interface
          • ☰ 1.4. Command Window, Workspace, and Current Folder
            • ☰ 1.5. Basic Workflow and Running Simple Commands
              • ☰ 1.6. Getting Help and Documentation
              • ☰ 2. MATLAB Language Basics
                • ☰ 2.1. MATLAB Syntax and Expressions
                  • ☰ 2.2. Variables and Assignment
                    • ☰ 2.3. Data Types and Type Conversion
                      • ☰ 2.4. Vectors and Matrices Fundamentals
                        • ☰ 2.5. Creating and Indexing Arrays
                          • ☰ 2.6. Basic Arithmetic and Elementwise Operations
                            • ☰ 2.7. Using Built-In Constants and Functions
                            • ☰ 3. Working with Variables and the Workspace
                              • ☰ 3.1. Creating, Viewing, and Editing Variables
                                • ☰ 3.2. Workspace Browser and Variable Inspector
                                  • ☰ 3.3. Saving and Loading Data Files
                                    • ☰ 3.4. MAT-Files and Importing External Data
                                      • ☰ 3.5. Clearing Variables and Managing the Workspace
                                      • ☰ 4. Vectors, Matrices, and Arrays
                                        • ☰ 4.1. Row and Column Vectors
                                          • ☰ 4.2. Matrix Creation and Concatenation
                                            • ☰ 4.3. Indexing, Slicing, and Logical Indexing
                                              • ☰ 4.4. Matrix Operations vs Elementwise Operations
                                                • ☰ 4.5. Reshaping and Rearranging Arrays
                                                  • ☰ 4.6. Special Matrices and Functions
                                                  • ☰ 5. Basic Programming Constructs
                                                    • ☰ 5.1. Scripts vs Functions
                                                      • ☰ 5.2. Control Flow with if, elseif, else
                                                        • ☰ 5.3. Loops with for and while
                                                          • ☰ 5.4. break, continue, and return
                                                            • ☰ 5.5. Logical Expressions and Relational Operators
                                                              • ☰ 5.6. Best Practices for Clear and Readable Code
                                                              • ☰ 6. Functions in MATLAB
                                                                • ☰ 6.1. Creating Simple Functions
                                                                  • ☰ 6.2. Function Inputs and Outputs
                                                                    • ☰ 6.3. Function Files and the Path
                                                                      • ☰ 6.4. Local vs Global Variables
                                                                        • ☰ 6.5. Anonymous Functions
                                                                          • ☰ 6.6. Organizing Code into Multiple Functions
                                                                          • ☰ 7. Working with Numbers and Math
                                                                            • ☰ 7.1. Scalars and Vectorized Computations
                                                                              • ☰ 7.2. Basic Mathematical Functions
                                                                                • ☰ 7.3. Trigonometric and Exponential Functions
                                                                                  • ☰ 7.4. Complex Numbers in MATLAB
                                                                                    • ☰ 7.5. Rounding, Modulo, and Special Values
                                                                                      • ☰ 7.6. Numerical Precision and Floating Point Considerations
                                                                                      • ☰ 8. Strings, Characters, and Categorical Data
                                                                                        • ☰ 8.1. Character Arrays and String Arrays
                                                                                          • ☰ 8.2. Creating and Manipulating Strings
                                                                                            • ☰ 8.3. Converting Between Data Types and Strings
                                                                                              • ☰ 8.4. Comparing and Searching Strings
                                                                                                • ☰ 8.5. Categorical Arrays Basics
                                                                                                • ☰ 9. Tables, Structures, and Cell Arrays
                                                                                                  • ☰ 9.1. Introduction to Tables
                                                                                                    • ☰ 9.2. Creating Tables and Accessing Data
                                                                                                      • ☰ 9.3. Modifying and Joining Tables
                                                                                                        • ☰ 9.4. Structures and Nested Structures
                                                                                                          • ☰ 9.5. Cell Arrays and Cell Indexing
                                                                                                            • ☰ 9.6. Choosing the Right Container Type
                                                                                                            • ☰ 10. Importing and Exporting Data
                                                                                                              • ☰ 10.1. Reading Text and CSV Files
                                                                                                                • ☰ 10.2. Importing Excel Spreadsheets
                                                                                                                  • ☰ 10.3. Importing Data with the Import Tool
                                                                                                                    • ☰ 10.4. Exporting Data to Files
                                                                                                                      • ☰ 10.5. Working with Image and Audio Files
                                                                                                                        • ☰ 10.6. Basic File Management from MATLAB
                                                                                                                        • ☰ 11. Plotting and Visualization
                                                                                                                          • ☰ 11.1. Introduction to 2D Plotting
                                                                                                                            • ☰ 11.2. Customizing Plots and Axes
                                                                                                                              • ☰ 11.3. Multiple Plots in One Figure
                                                                                                                                • ☰ 11.4. Labels, Titles, Legends, and Annotations
                                                                                                                                  • ☰ 11.5. Plotting with Different Line and Marker Styles
                                                                                                                                    • ☰ 11.6. Saving and Exporting Figures
                                                                                                                                    • ☰ 12. Advanced Plotting for Beginners
                                                                                                                                      • ☰ 12.1. Subplots and Tiled Layouts
                                                                                                                                        • ☰ 12.2. Bar, Scatter, and Stem Plots
                                                                                                                                          • ☰ 12.3. Histograms and Density Plots
                                                                                                                                            • ☰ 12.4. 3D Plots and Surface Plots
                                                                                                                                              • ☰ 12.5. Using plottools and Interactive Editing
                                                                                                                                                • ☰ 12.6. Basics of Handle Graphics
                                                                                                                                                • ☰ 13. Working with Scripts and Live Scripts
                                                                                                                                                  • ☰ 13.1. Creating and Running Script Files
                                                                                                                                                    • ☰ 13.2. Sectioning Code and Running Sections
                                                                                                                                                      • ☰ 13.3. Live Scripts and Rich Text
                                                                                                                                                        • ☰ 13.4. Adding Equations, Images, and Outputs
                                                                                                                                                          • ☰ 13.5. Sharing and Exporting Live Scripts
                                                                                                                                                          • ☰ 14. Debugging and Code Quality
                                                                                                                                                            • ☰ 14.1. Finding and Fixing Syntax Errors
                                                                                                                                                              • ☰ 14.2. Setting Breakpoints and Stepping Through Code
                                                                                                                                                                • ☰ 14.3. Inspecting Variable Values During Execution
                                                                                                                                                                  • ☰ 14.4. Using the Editor Debugging Tools
                                                                                                                                                                    • ☰ 14.5. Using Code Analyzer and Warnings
                                                                                                                                                                      • ☰ 14.6. Writing Clean and Maintainable MATLAB Code
                                                                                                                                                                      • ☰ 15. Basic Linear Algebra with MATLAB
                                                                                                                                                                        • ☰ 15.1. Vectors and Norms
                                                                                                                                                                          • ☰ 15.2. Matrix Addition and Multiplication
                                                                                                                                                                            • ☰ 15.3. Solving Linear Systems with Backslash
                                                                                                                                                                              • ☰ 15.4. Inverses, Determinants, and Rank
                                                                                                                                                                                • ☰ 15.5. Eigenvalues and Eigenvectors
                                                                                                                                                                                  • ☰ 15.6. Using Linear Algebra Functions Safely
                                                                                                                                                                                  • ☰ 16. Data Analysis and Statistics Fundamentals
                                                                                                                                                                                    • ☰ 16.1. Descriptive Statistics and Summary Measures
                                                                                                                                                                                      • ☰ 16.2. Sorting, Filtering, and Grouping Data
                                                                                                                                                                                        • ☰ 16.3. Basic Correlation and Regression
                                                                                                                                                                                          • ☰ 16.4. Simple Data Cleaning Techniques
                                                                                                                                                                                            • ☰ 16.5. Basic Time Series Handling
                                                                                                                                                                                            • ☰ 17. Working with Time and Dates
                                                                                                                                                                                              • ☰ 17.1. Representing Dates and Times
                                                                                                                                                                                                • ☰ 17.2. Creating and Formatting datetime Arrays
                                                                                                                                                                                                  • ☰ 17.3. Date Calculations and Differences
                                                                                                                                                                                                    • ☰ 17.4. Plotting Data over Time
                                                                                                                                                                                                    • ☰ 18. Introduction to Signal and Image Handling
                                                                                                                                                                                                      • ☰ 18.1. Basic Signal Representation in MATLAB
                                                                                                                                                                                                        • ☰ 18.2. Simple Filtering and Transformations
                                                                                                                                                                                                          • ☰ 18.3. Reading, Displaying, and Writing Images
                                                                                                                                                                                                            • ☰ 18.4. Basic Image Transformations
                                                                                                                                                                                                            • ☰ 19. Automation and Scripting Tasks
                                                                                                                                                                                                              • ☰ 19.1. Batch Processing of Files
                                                                                                                                                                                                                • ☰ 19.2. Writing Reusable Utility Scripts
                                                                                                                                                                                                                  • ☰ 19.3. Using Relative Paths and the MATLAB Path
                                                                                                                                                                                                                    • ☰ 19.4. Simple User Interaction with input and disp
                                                                                                                                                                                                                    • ☰ 20. Introduction to Toolboxes
                                                                                                                                                                                                                      • ☰ 20.1. What Are Toolboxes and How to Use Them
                                                                                                                                                                                                                        • ☰ 20.2. Exploring Installed Toolboxes
                                                                                                                                                                                                                          • ☰ 20.3. Finding Functions in Toolboxes
                                                                                                                                                                                                                            • ☰ 20.4. Add-Ons and MATLAB File Exchange
                                                                                                                                                                                                                            • ☰ 21. Best Practices and Next Steps
                                                                                                                                                                                                                              • ☰ 21.1. Organizing Projects and Folders
                                                                                                                                                                                                                                • ☰ 21.2. Version Control Basics with MATLAB
                                                                                                                                                                                                                                  • ☰ 21.3. Performance Tips for Beginners
                                                                                                                                                                                                                                    • ☰ 21.4. Learning Resources and Documentation Path
                                                                                                                                                                                                                                      • ☰ 21.5. Suggested Practice Projects for Beginners