# resize

Resize data by adding or removing elements

Since R2023b

## Syntax

``B = resize(A,m)``
``B = resize(A,m,Name=Value)``

## Description

example

````B = resize(A,m)` resizes `A` to size `m` by adding elements to or removing elements from the trailing side of `A`. For example, for a scalar size `m`: If `A` is a vector, then `resize(A,m)` pads or trims `A` to length `m`.If `A` is a matrix, table, or timetable, then `resize(A,m)` pads or trims `A` to have `m` rows.If `A` is a multidimensional array, then `resize(A,m)` pads or trims `A` to the size specified by `m` along the first dimension whose size is greater than 1. ```

example

````B = resize(A,m,Name=Value)` specifies additional parameters for resizing using one or more name-value arguments. For example, `resize(A,m,Pattern="circular")`, where `m` is greater than the size of `A` in the operating dimension, resizes by repeating the input data circularly.```

## Examples

collapse all

Create a four-element column vector, and resize the vector to six elements. By default, the `resize` function adds zeros to the trailing side of the numeric vector.

```A = [1; 3; 5; 7]; B1 = resize(A,6)```
```B1 = 6×1 1 3 5 7 0 0 ```

Resize the vector to two elements. By default, `resize` removes elements from the trailing side.

`B2 = resize(A,2)`
```B2 = 2×1 1 3 ```

Create three vectors with different lengths.

```A1 = [2; 8; 3]; A2 = [9; 4; 6; 2; 7]; A3 = [9; 2; 6; 1; 9; 3];```

Determine the length of the second vector.

`m = length(A2)`
```m = 5 ```

Resize the first and third vectors to match the length of the second vector. `resize` adds elements to the end of `A1` and removes an element from the end of `A3`.

`B1 = resize(A1,m)`
```B1 = 5×1 2 8 3 0 0 ```
`B3 = resize(A3,m)`
```B3 = 5×1 9 2 6 1 9 ```

You can concatenate vectors of the same length. Create a matrix using the resized vectors.

`C = [B1 A2 B3]`
```C = 5×3 2 9 9 8 4 2 3 6 6 0 2 1 0 7 9 ```

You can also resize data using the `paddata` and `trimdata` functions. Use the `paddata` function to resize the vector shorter than the target length, and use the `trimdata` function to resize the vector longer than the target length.

`D1 = paddata(A1,m)`
```D1 = 5×1 2 8 3 0 0 ```
`D3 = trimdata(A3,m)`
```D3 = 5×1 9 2 6 1 9 ```

Create a 3-by-3 matrix. Resize the columns to a length of 2 by removing one element from each column. Resize the rows to a length of 9 by reflecting the data in each row until the row contains nine elements. `Pattern` applies only to the dimension for which `resize` adds elements.

`A = [1 3 5; 2 4 6; 7 8 10]`
```A = 3×3 1 3 5 2 4 6 7 8 10 ```
`B = resize(A,[2 9],Pattern="reflect")`
```B = 2×9 1 3 5 3 1 3 5 3 1 2 4 6 4 2 4 6 4 2 ```

Create a 3-by-3 matrix as the first page in a 3-D array. Add a second page to the array by resizing along the third dimension.

`A = [1 3 5; 2 4 6; 7 8 10]`
```A = 3×3 1 3 5 2 4 6 7 8 10 ```
`B = resize(A,2,Dimension=3)`
```B = B(:,:,1) = 1 3 5 2 4 6 7 8 10 B(:,:,2) = 0 0 0 0 0 0 0 0 0 ```

Create a timetable with variables of different data types.

```num = [10; 20; 30]; cat = categorical(["A"; "B"; "A"]); log = logical([1; 0; 1]); str = ["Text 1"; "Text 2"; "Text 3"]; TT = timetable(num,cat,log,str,Timestep=hours(2))```
```TT=3×4 timetable Time num cat log str ____ ___ ___ _____ ________ 0 hr 10 A true "Text 1" 2 hr 20 B false "Text 2" 4 hr 30 A true "Text 3" ```

Resize each timetable variable to six elements. `resize` uses the default fill value for the data type of each variable. The default fill value for each data type is the same as the value of elements that MATLAB® creates when assigning a value beyond the last row of the table.

`B1 = resize(TT,6)`
```B1=6×4 timetable Time num cat log str _____ ___ ___________ _____ _________ 0 hr 10 A true "Text 1" 2 hr 20 B false "Text 2" 4 hr 30 A true "Text 3" 6 hr 0 <undefined> false <missing> 8 hr 0 <undefined> false <missing> 10 hr 0 <undefined> false <missing> ```

Specify a custom fill value for the elements to add to each timetable variable. `resize` extends the row times, so you do not need to specify a fill value for the row times.

`B2 = resize(TT,6,FillValue={mean(num),"C",1,""})`
```B2=6×4 timetable Time num cat log str _____ ___ ___ _____ ________ 0 hr 10 A true "Text 1" 2 hr 20 B false "Text 2" 4 hr 30 A true "Text 3" 6 hr 20 C true "" 8 hr 20 C true "" 10 hr 20 C true "" ```

Create a vector in which the first few and last few elements are unneeded. Resize the vector by removing elements from the leading and trailing sides. Because the number of elements to remove is odd, `resize` removes one more element from the trailing side of the vector than the leading side.

```A = [0.1 1 2 3 3 2 1 0 NaN]; B = resize(A,6,Side="both")```
```B = 1×6 1 2 3 3 2 1 ```

## Input Arguments

collapse all

Input data, specified as a vector, matrix, multidimensional array, table, timetable, cell array, or structure array.

Note

If `A` is a cell array, then `resize` changes the size of the entire array. It does not change the size of each cell in the array. Use the `cellfun` function to apply `resize` to each cell in a cell array.

Size of resized data along operating dimension, specified as a nonnegative integer scalar or vector of nonnegative integers. Each element represents the size of the resized data in an operating dimension.

• If `m` is greater than the size of `A` in the operating dimension, then `resize` adds elements.

• If `m` is less than the size of `A` in the operating dimension, then `resize` removes elements.

### Name-Value Arguments

Specify optional pairs of arguments as `Name1=Value1,...,NameN=ValueN`, where `Name` is the argument name and `Value` is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Example: `B = resize(A,m,Pattern="circular")`

Dimensions to operate along, specified as `"auto"`, a positive integer scalar, or a vector of positive integers. Each element represents a dimension of the input data.

If `Dimension` is `"auto"`, then the operating dimension depends on the input arguments:

• If `m` is a scalar and `A` is an array, then the operating dimension is the first dimension whose size is greater than 1.

• If `m` is a vector, then the operating dimensions are `1:numel(m)`.

• If `A` is a table or timetable and `resize` is adding elements, then the operating dimension is `1`, and operation is along each table or timetable variable separately.

• If `A` is a table or timetable and `resize` is removing elements, then the operating dimension is `1` or `[1 2]`, depending on the number of elements in `m`.

Fill value for added elements, specified as a scalar, cell array, or scalar structure.

The default fill value for each class is the same as the value of elements that MATLAB® creates when assigning a value past the end of a vector. For example, the default fill value for numeric input data is 0.

• If `A` is an array, then a scalar `FillValue` indicates the value for all elements added to `A` during resizing.

• If `A` is a table or timetable, then a cell array `FillValue` indicates a different fill value for elements added to each table or timetable variable. The number of cells in the cell array must match the number of table or timetable variables. If `A` is a table with row names, then `resize` extends the row names with the default row name, such as `RowN`; it does not resize the row names using `FillValue`. If `A` is a timetable with row times, then `resize` extends the row times; it does not resize the row times using `FillValue`.

• If `A` is a structure array, then a scalar structure `FillValue` indicates a different fill value for each field in the input data. The number and names of fields in `FillValue` must match the number and names of fields in the input data.

If you specify `FillValue`, you cannot specify `Pattern`.

Pattern for adding elements, specified as one of the pattern names in the table. The pattern is repeated until the resized data has size `m`.

• If `A` is a table with row names, then `resize` extends the row names with the default row name, such as `RowN`; it does not add to the row names using `Pattern`.

• If `A` is a timetable with row times, then `resize` extends the row times; it does not add to the row times using `Pattern`.

If you specify `Pattern`, you cannot specify `FillValue`.

This table lists the pattern names with a description and a sample of how each pattern resizes the input data `A = [1 2 3]`.

Pattern NameDescription Resized Data
`"constant"`Pad data with the default value determined by the data type of `A`.

`"edge"`Pad data by replicating the leading and trailing endpoints as constant fill values.

`"circular"`Pad data by repeating the input data circularly.

`"flip"`Pad data by flipping the input data symmetrically. Endpoints are duplicated.

`"reflect"`Pad data by reflecting the input data. Endpoints are not duplicated.

Side of input data for resizing, specified as one of these values:

• `"trailing"` — Pad `A` with trailing elements, or trim the trailing elements of `A`.

• `"leading"` — Pad `A` with leading elements, or trim the leading elements of `A`.

• `"both"` — Resize `A` on both sides. If the number of elements to add or remove in the operating dimension is even, then pad or trim the trailing and leading sides of `A` evenly. If the number of elements to add or remove in the operating dimension is odd, then pad or trim the remaining element on the trailing side of `A`.

## Tips

• `resize` returns resized data with a size that respects the specified sizes in `m`. `resize` is recommended if you require resized data that matches the target size. If you want only to add elements to your data, consider using the `paddata` function, which does not trim data. If you want only to remove elements from your data, consider using the `trimdata` function, which does not pad with additional data.

• The `resize` function adds or removes elements from the input data. To rearrange existing elements, use the `reshape` function.

## Version History

Introduced in R2023b