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.

# repmat

Repeat copies of array

## Syntax

``B = repmat(A,n)``
``B = repmat(A,r1,...,rN)``
``B = repmat(A,r)``

## Description

example

````B = repmat(A,n)` returns an array containing `n` copies of `A` in the row and column dimensions. The size of `B` is `size(A)*n` when `A` is a matrix.```

example

````B = repmat(A,r1,...,rN)` specifies a list of scalars, `r1,..,rN`, that describes how copies of `A` are arranged in each dimension. When `A` has `N` dimensions, the size of `B` is `size(A).*[r1...rN]`. For example, `repmat([1 2; 3 4],2,3)` returns a 4-by-6 matrix.```

example

````B = repmat(A,r)` specifies the repetition scheme with row vector `r`. For example, ```repmat(A,[2 3])``` returns the same result as `repmat(A,2,3)`.```

## Examples

collapse all

Create a 3-by-2 matrix whose elements contain the value 10.

`A = repmat(10,3,2)`
```A = 3×2 10 10 10 10 10 10 ```

Repeat copies of a matrix into a 2-by-2 block arrangement.

`A = diag([100 200 300])`
```A = 3×3 100 0 0 0 200 0 0 0 300 ```
`B = repmat(A,2)`
```B = 6×6 100 0 0 100 0 0 0 200 0 0 200 0 0 0 300 0 0 300 100 0 0 100 0 0 0 200 0 0 200 0 0 0 300 0 0 300 ```

Repeat copies of a matrix into a 2-by-3 block arrangement.

`A = diag([100 200 300])`
```A = 3×3 100 0 0 0 200 0 0 0 300 ```
`B = repmat(A,2,3)`
```B = 6×9 100 0 0 100 0 0 100 0 0 0 200 0 0 200 0 0 200 0 0 0 300 0 0 300 0 0 300 100 0 0 100 0 0 100 0 0 0 200 0 0 200 0 0 200 0 0 0 300 0 0 300 0 0 300 ```

Repeat copies of a matrix into a 2-by-3-by-2 block arrangement.

`A = [1 2; 3 4]`
```A = 2×2 1 2 3 4 ```
`B = repmat(A,[2 3 2])`
```B = B(:,:,1) = 1 2 1 2 1 2 3 4 3 4 3 4 1 2 1 2 1 2 3 4 3 4 3 4 B(:,:,2) = 1 2 1 2 1 2 3 4 3 4 3 4 1 2 1 2 1 2 3 4 3 4 3 4 ```

Vertically stack a row vector four times.

```A = 1:4; B = repmat(A,4,1)```
```B = 4×4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 ```

Horizontally stack a column vector four times.

```A = (1:3)'; B = repmat(A,1,4)```
```B = 3×4 1 1 1 1 2 2 2 2 3 3 3 3 ```

Create a table with variables `Age` and `Height`.

`A = table([39; 26],[70; 63],'VariableNames',{'Age' 'Height'})`
```A=2×2 table Age Height ___ ______ 39 70 26 63 ```

Repeat copies of the table into a 2-by-3 block format.

`B = repmat(A,2,3)`
```B=4×6 table Age Height Age_1 Height_1 Age_2 Height_2 ___ ______ _____ ________ _____ ________ 39 70 39 70 39 70 26 63 26 63 26 63 39 70 39 70 39 70 26 63 26 63 26 63 ```

`repmat` repeats the entries of the table and appends a number to the new variable names.

## 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` | `string` | `struct` | `table` | `cell`
Complex Number Support: Yes

Number of times to repeat the input array in the row and column dimensions, specified as an integer value. If `n` is `0` or negative, the result is an empty array.

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

Repetition factors for each dimension, specified as separate arguments of integer values. If any repetition factor is `0` or negative, the result is an empty array.

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

Vector of repetition factors for each dimension, specified as a row vector of integer values. If any value in `r` is `0` or negative, the result is an empty array.

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

## Tips

• To build block arrays by forming the tensor product of the input with an array of ones, use `kron`. For example, to stack the row vector `A = 1:3` four times vertically, you can use `B = kron(A,ones(4,1))`.

• To create block arrays and perform a binary operation in a single pass, use `bsxfun`. In some cases, `bsxfun` provides a simpler and more memory efficient solution. For example, to add the vectors ```A = 1:5``` and `B = (1:10)'` to produce a 10-by-5 array, use `bsxfun(@plus,A,B)` instead of ```repmat(A,10,1) + repmat(B,1,5)```.

• When `A` is a scalar of a certain type, you can use other functions to get the same result as `repmat`.

repmat SyntaxEquivalent Alternative
`repmat(NaN,m,n)``NaN(m,n)`
`repmat(single(inf),m,n)``inf(m,n,'single')`
`repmat(int8(0),m,n)``zeros(m,n,'int8')`
`repmat(uint32(1),m,n)``ones(m,n,'uint32')`
`repmat(eps,m,n)``eps(ones(m,n))`

Download eBook