# reshape

Reshape array by rearranging existing elements

## Description

reshapes `B`

= reshape(`A`

,`sz1,...,szN`

)`A`

into
a `sz1`

-by-`...`

-by-`szN`

array
where `sz1,...,szN`

indicates the size of each dimension.
You can specify a single dimension size of `[]`

to
have the dimension size automatically calculated, such that the number
of elements in `B`

matches the number of elements
in `A`

. For example, if `A`

is a
10-by-10 matrix, then `reshape(A,2,2,[])`

reshapes
the 100 elements of `A`

into a 2-by-2-by-25 array.

## Examples

### Reshape Vector into Matrix

Reshape a 1-by-10 vector into a 5-by-2 matrix.

A = 1:10; B = reshape(A,[5,2])

`B = `*5×2*
1 6
2 7
3 8
4 9
5 10

### Reshape Matrix to Have Specified Number of Columns

Reshape a 4-by-4 square matrix into a matrix that has 2 columns. Specify `[]`

for the first dimension to let `reshape`

automatically calculate the appropriate number of rows.

A = magic(4)

`A = `*4×4*
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1

B = reshape(A,[],2)

`B = `*8×2*
16 3
5 10
9 6
4 15
2 13
11 8
7 12
14 1

The result is an 8-by-2 matrix, which maintains the same number of elements as the original matrix. The elements in `B`

also maintain their columnwise order from `A`

.

### Reshape Multidimensional Array into Matrix

Reshape a 2-by-2-by-3 array of random values into a 6-by-2 matrix.

```
rng default
A = rand(2,2,3)
```

A = A(:,:,1) = 0.8147 0.1270 0.9058 0.9134 A(:,:,2) = 0.6324 0.2785 0.0975 0.5469 A(:,:,3) = 0.9575 0.1576 0.9649 0.9706

B = reshape(A,6,2)

`B = `*6×2*
0.8147 0.2785
0.9058 0.5469
0.1270 0.9575
0.9134 0.9649
0.6324 0.1576
0.0975 0.9706

## Input Arguments

`A`

— Input array

vector | matrix | multidimensional array

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

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `logical`

| `char`

| `string`

| `cell`

| `struct`

| `datetime`

| `duration`

| `calendarDuration`

**Complex Number Support: **Yes

`sz`

— Output size

row vector of integers

Output size, specified as a row vector of integers. Each element
of `sz`

indicates the size of the corresponding dimension
in `B`

. You must specify `sz`

so
that the number of elements in `A`

and `B`

are
the same. That is, `prod(sz)`

must be the same as `numel(A)`

.

Beyond the second dimension, the output, `B`

,
does not reflect trailing dimensions with a size of `1`

.
For example, `reshape(A,[3,2,1,1])`

produces a 3-by-2
matrix.

**Example: **`reshape(A,[3,2])`

**Example: **`reshape(A,[6,4,10])`

**Example: **`reshape(A,[5,5,5,5])`

`sz1,...,szN`

— Size of each dimension

two or more integers | `[]`

(optional)

Size of each dimension, specified as two or more integers with
at most one `[]`

(optional). You must specify at
least 2 dimension sizes, and at most one dimension size can be specified
as `[]`

, which automatically calculates the size
of that dimension to ensure that `numel(B)`

matches `numel(A)`

.
When you use `[]`

to automatically calculate a dimension
size, the dimensions that you *do* explicitly specify
must divide evenly into the number of elements in the input matrix, `numel(A)`

.

Beyond the second dimension, the output, `B`

,
does not reflect trailing dimensions with a size of `1`

.
For example, `reshape(A,3,2,1,1)`

produces a 3-by-2
matrix.

**Example: **`reshape(A,3,2)`

**Example: **`reshape(A,6,[],10)`

**Example: **`reshape(A,2,5,3,[])`

**Example: **`reshape(A,5,5,5,5)`

## Output Arguments

`B`

— Reshaped array

vector | matrix | multidimensional array | cell array

Reshaped array, returned as a vector, matrix, multidimensional
array, or cell array. The data type and number of elements in `B`

are
the same as the data type and number of elements in `A`

.
The elements in `B`

preserve their columnwise ordering
from `A`

.

**Data Types: **`single`

| `double`

| `int8`

| `int16`

| `int32`

| `int64`

| `uint8`

| `uint16`

| `uint32`

| `uint64`

| `logical`

| `char`

| `string`

| `cell`

| `datetime`

| `duration`

| `calendarDuration`

## Tips

The

`reshape`

function rearranges existing elements in the input data. To add or remove elements, use the`resize`

function.

## Extended Capabilities

### Tall Arrays

Calculate with arrays that have more rows than fit in memory.

This function supports tall arrays with the limitations:

Reshaping the tall dimension (dimension one) is not supported. The first dimension input should always be empty, such as

`reshape(X,[],M,N,...)`

.

For more information, see Tall Arrays for Out-of-Memory Data.

### C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

If the input is a compile-time empty cell array, then the size arguments must be constants.

Size arguments must have a fixed size.

See Variable-Sizing Restrictions for Code Generation of Toolbox Functions (MATLAB Coder).

For sparse matrices, the

`reshape`

function does not support trailing ones as inputs after the first two dimensions.

### GPU Code Generation

Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Usage notes and limitations:

If the input is a compile-time empty cell array, then the size arguments must be constants.

Size arguments must have a fixed size.

For sparse matrices, the

`reshape`

function does not support trailing ones as inputs after the first two dimensions.

### HDL Code Generation

Generate VHDL, Verilog and SystemVerilog code for FPGA and ASIC designs using HDL Coder™.

### Thread-Based Environment

Run code in the background using MATLAB® `backgroundPool`

or accelerate code with Parallel Computing Toolbox™ `ThreadPool`

.

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

### GPU Arrays

Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

The `reshape`

function
supports GPU array input with these usage notes and limitations:

Input array

`A`

must be nonsparse.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

### Distributed Arrays

Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

This function fully supports distributed arrays. For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

## Version History

**Introduced before R2006a**

## MATLAB Command

You clicked a link that corresponds to this MATLAB command:

Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.

Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

## How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

### Americas

- América Latina (Español)
- Canada (English)
- United States (English)

### Europe

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)