# 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`. This syntax is valid for MATLAB® versions R2018b and later.```

example

````B = all(A,dim)` tests elements along dimension `dim`. The `dim` input is a positive integer scalar.```

example

````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 ```

Create a 3-D array and determine if all elements in each page of data (rows and columns) are zero.

```A(:,:,1) = [2 1; 3 5]; A(:,:,2) = [0 0; 0 0]; A(:,:,3) = [-2 9; 4 1]; B = all(A,[1 2])```
```B = 1x1x3 logical array B(:,:,1) = 1 B(:,:,2) = 0 B(:,:,3) = 1 ```

## 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 you do not specify the dimension, then the default is the first array dimension of size greater than 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`.

## Version History

Introduced before R2006a