Sometimes the result of a calculation produces
an entire numeric or logical array when you need only a single logical `true`

or `false`

value.
In this case, use the `any`

or `all`

functions
to reduce the array to a single scalar logical for further computations.

The `any`

and `all`

functions
are natural extensions of the logical `|`

(OR) and `&`

(AND)
operators, respectively. However, rather than comparing just two elements,
the `any`

and `all`

functions compare
all of the elements in a particular dimension of an array. It is as
if all of those elements are connected by `&`

or `|`

operators
and the `any`

or `all`

functions
evaluate the resulting long logical expression(s). Therefore, unlike
the core logical operators, the `any`

and `all`

functions
reduce the size of the array dimension that they operate on so that
it has size 1. This enables the reduction of many logical values into
a single logical condition.

First, create a matrix, `A`

, that contains
random integers between 1 and 25.

rng(0) A = randi(25,5)

A = 21 3 4 4 17 23 7 25 11 1 4 14 24 23 22 23 24 13 20 24 16 25 21 24 17

Next, use the `mod`

function along with the
logical NOT operator, `~`

, to determine which elements
in `A`

are even.

A = ~mod(A,2)

A = 0 0 1 1 0 0 0 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 0 1 0

The resulting matrices have values of logical `1`

(`true`

)
where an element is even, and logical `0`

(`false`

)
where an element is odd.

Since the `any`

and `all`

functions
reduce the dimension that they operate on to size 1, it normally takes
two applications of one of the functions to reduce a 2–D matrix
into a single logical condition, such as `any(any(A))`

.
However, if you use the notation `A(:)`

to regard
all of the elements of `A`

as a single column vector,
you can use `any(A(:))`

to get the same logical information
without nesting the function calls.

Determine if any elements in `A`

are even.

any(A(:))

ans = 1

The result is logical `1`

(`true`

).

You can perform logical and relational comparisons within the
function call to `any`

or `all`

.
This makes it easy to quickly test an array for a variety of properties.

Determine if all elements in `A`

are odd.

all(~A(:))

ans = 0

The result is logical `0`

(`false`

).

Determine whether any main or super diagonal elements in `A`

are
even.

any(diag(A) | diag(A,1))

Error using | Inputs must have the same size.

MATLAB^{®} returns an error since the vectors returned by `diag(A)`

and `diag(A,1)`

are
not the same size.

To reduce each diagonal to a single scalar logical condition
and allow logical short-circuiting, use the `any`

function
on each side of the short-circuit OR operator, `||`

.

any(diag(A)) || any(diag(A,1))

ans = 1

The result is logical `1`

(`true`

).
It no longer matters that `diag(A)`

and `diag(A,1)`

are
not the same size.

`all`

| `and`

| `any`

| ```
Logical Operators:
Short Circuit
```

| `or`

| `xor`

Was this topic helpful?