Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English version of the page.

Note: This page has been translated by MathWorks. Click here to see
To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

# all

Determine if all array elements are nonzero or `true`

## Syntax

``B = all(A)``
``B = all(A,'all')``
``B = all(A,dim)``
``B = all(A,vecdim)``

## Description

example

````B = all(A)` tests along the first array dimension of `A` whose size does not equal 1, and determines if the elements are all nonzero or logical `1` (`true`). In practice, `all` is a natural extension of the logical AND operator. If `A` is a vector, then `all(A)` returns logical `1` (`true`) if all the elements are nonzero and returns logical `0` (`false`) if one or more elements are zero.If `A` is a nonempty matrix, then `all(A)` treats the columns of `A` as vectors and returns a row vector of logical `1`s and `0`s.If `A` is an empty 0-by-0 matrix, then `all(A)` returns logical `1` (`true`).If `A` is a multidimensional array, then `all(A)` acts along the first array dimension whose size does not equal 1 and returns an array of logical values. The size of this dimension becomes `1`, while the sizes of all other dimensions remain the same. ```
````B = all(A,'all')` tests over all elements of `A`.```

example

````B = all(A,dim)` tests elements along dimension `dim`. The `dim` input is a positive integer scalar.```
````B = all(A,vecdim)` tests elements based on the dimensions specified in the vector `vecdim`. For example, if `A` is a matrix, then `all(A,[1 2])` tests over all elements in `A`, since every element of a matrix is contained in the array slice defined by dimensions 1 and 2.```

## Examples

collapse all

Create a 3-by-3 matrix, and then test each column for all nonzero elements.

`A = [0 0 3;0 0 3;0 0 3]`
```A = 3×3 0 0 3 0 0 3 0 0 3 ```
`B = all(A)`
```B = 1x3 logical array 0 0 1 ```

Create a vector of decimal values and test which values are less than 0.5.

```A = [0.53 0.67 0.01 0.38 0.07 0.42 0.69]; B = (A < 0.5)```
```B = 1x7 logical array 0 0 1 1 1 1 0 ```

The output is a vector of logical values. The `all` function reduces such a vector of logical values to a single condition. In this case, `B = all(A < 0.5)` yields logical `0`.

This makes `all` particularly useful in `if` statements.

` if all(A < 0.5)`

` %do something`

` else`

` %do something else`

` end `

The code is executed depending on a single condition, rather than a vector of possibly conflicting conditions.

Create a 3-by-7-by-5 multidimensional array and test to see if all of its elements are less than 3.

```A = rand(3,7,5) * 5; B = all(A(:) < 3)```
```B = logical 0 ```

You can also test the array for elements that are greater than zero.

`B = all(A(:) > 0)`
```B = logical 1 ```

The syntax `A(:)` turns the elements of `A` into a single column vector, so you can use this type of statement on an array of any size.

Create a 3-by-3 matrix.

`A = [0 0 3;0 0 3;0 0 3]`
```A = 3×3 0 0 3 0 0 3 0 0 3 ```

Test the rows of `A` for all nonzero elements by specifying `dim = 2`.

`B = all(A,2)`
```B = 3x1 logical array 0 0 0 ```

## Input Arguments

collapse all

Input array, specified as a scalar, vector, matrix, or multidimensional array.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `char`
Complex Number Support: Yes

Dimension to operate along, specified as a positive integer scalar. If no value is specified, then the default is the first array dimension whose size does not equal 1.

Consider a two-dimensional input array, `A`:

• `all(A,1)` works on successive elements in the columns of `A` and returns a row vector of logical values.

• `all(A,2)` works on successive elements in the rows of `A` and returns a column vector of logical values.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Vector of dimensions, specified as a vector of positive integers. Each element represents a dimension of the input array. The lengths of the output in the specified operating dimensions are 1, while the others remain the same.

Consider a 2-by-3-by-3 input array, `A`. Then `all(A,[1 2])` returns a 1-by-1-by-3 array whose elements indicate nonzero values for each page of `A`.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

## Output Arguments

collapse all

Logical array, returned as a scalar, vector, matrix, or multidimensional array. The dimension of `A` acted on by `all` has size `1` in `B`.

Download eBook