# zeros

Create array of all zeros

## Syntax

• `X = zeros`
• `X = zeros(n)` example
• `X = zeros(sz1,...,szN)` example
• `X = zeros(sz)` example
• `X = zeros(___,typename)` example
• `X = zeros(___,'like',p)` example

## Description

``X = zeros` returns the scalar `0`.`

example

````X = zeros(n)` returns an `n`-by-`n` matrix of zeros.```

example

````X = zeros(sz1,...,szN)` returns an `sz1`-by-...-by-`szN` array of zeros where `sz1,...,szN` indicate the size of each dimension. For example, `zeros(2,3)` returns a 2-by-3 matrix.```

example

````X = zeros(sz)` returns an array of zeros where size vector `sz` defines `size(X)`. For example, `zeros([2 3])` returns a 2-by-3 matrix.```

example

````X = zeros(___,typename)` returns an array of zeros of data type `typename`. For example, `zeros('int8')` returns a scalar, 8-bit integer `0`. You can use any of the input arguments in the previous syntaxes.```

example

````X = zeros(___,'like',p)` returns an array of zeros like `p`; that is, of the same data type (class), sparsity, and complexity (real or complex) as `p`. You can specify `typename` or `'like'`, but not both.```

## Examples

collapse all

### Matrix of Zeros

Create a 4-by-4 matrix of zeros.

`X = zeros(4)`
```X = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0```

### 3-D Array of Zeros

Create a 2-by-3-by-4 array of zeros.

```X = zeros(2,3,4); size(X)```
```ans = 2 3 4```

### Clone Size from Existing Array

Create an array of zeros that is the same size as an existing array.

```A = [1 4; 2 5; 3 6]; sz = size(A); X = zeros(sz) ```
```X = 0 0 0 0 0 0```

It is a common pattern to combine the previous two lines of code into a single line:

`X = zeros(size(A));`

### Specify Data Type of Zeros

Create a 1-by-3 vector of zeros whose elements are 32-bit unsigned integers.

```X = zeros(1,3,'uint32') ```
```X = 0 0 0 ```
`class(X)`
```ans = uint32```

### Clone Complexity from Existing Array

Create a scalar `0` that is complex like an existing array instead of real valued.

First, create a complex vector.

```p = [1+2i 3i]; ```

Create a scalar `0` that is complex like `p`.

```X = zeros('like',p) ```
```X = 0.0000 + 0.0000i```

### Clone Sparsity from Existing Array

Create a 10-by-10 sparse matrix.

```p = sparse(10,10,pi); ```

Create a 2-by-3 matrix of zeros that is sparse like `p`.

`X = zeros(2,3,'like',p)`
```X = All zero sparse: 2-by-3```

### Clone Size and Data Type from Existing Array

Create a 2-by-3 array of 8-bit unsigned integers.

```p = uint8([1 3 5 ; 2 4 6]); ```

Create an array of zeros that is the same size and data type as `p`.

```X = zeros(size(p),'like',p) ```
```X = 0 0 0 0 0 0 ```
`class(X)`
```ans = uint8```

### Clone Distributed Array

If you have Parallel Computing Toolbox™, create a 1000-by-1000 distributed array of zeros with underlying data type `int8`. For the `distributed` data type, the `'like'` syntax clones the underlying data type in addition to the primary data type.

`p = zeros(1000,'int8','distributed');`

Create an array of zeros that is the same size, primary data type, and underlying data type as `p`.

`X = zeros(size(p),'like',p);`
`class(X)`
```ans = distributed```
```classUnderlying(X) ```
```ans = int8```

## Input Arguments

collapse all

### `n` — Size of square matrixinteger value

Size of square matrix, specified as an integer value.

• If `n` is `0`, then `X` is an empty matrix.

• If `n` is negative, then it is treated as `0`.

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

### `sz1,...,szN` — Size of each dimension (as separate arguments)integer values

Size of each dimension, specified as separate arguments of integer values.

• If the size of any dimension is `0`, then `X` is an empty array.

• If the size of any dimension is negative, then it is treated as `0`.

• Beyond the second dimension, `zeros` ignores trailing dimensions with a size of `1`. For example, `zeros([3,1,1,1])` produces a 3-by-1 vector of zeros.

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

### `sz` — Size of each dimension (as a row vector)integer values

Size of each dimension, specified as a row vector of integer values. Each element of this vector indicates the size of the corresponding dimension:

• If the size of any dimension is `0`, then `X` is an empty array.

• If the size of any dimension is negative, then it is treated as `0`.

• Beyond the second dimension, `zeros` ignores trailing dimensions with a size of `1`. For example, `zeros([3,1,1,1])` produces a 3-by-1 vector of zeros.

Example: `sz = [2,3,4]` creates a 2-by-3-by-4 array.

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

### `typename` — Data type (class) to create`'double'` (default) | `'single'` | `'int8'` | `'uint8'` | ...

Data type (class) to create, specified as the string `'double'`, `'single'`, `'int8'`, `'uint8'`, `'int16'`, `'uint16'`, `'int32'`, `'uint32'`, `'int64'`, `'uint64'`, or the name of another class that provides `zeros` support.

### `p` — Prototype of array to createnumeric array

Prototype of array to create, specified as a numeric array.

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