# randi

Uniformly distributed pseudorandom integers

## Syntax

``X = randi(imax)``
``X = randi(imax,n)``
``X = randi(imax,sz1,...,szN)``
``X = randi(imax,sz)``
``X = randi(___,typename)``
``X = randi(___,"like",p)``
``X = randi([imin,imax],___)``
``X = randi(s,___)``

## Description

````X = randi(imax)` returns a pseudorandom scalar integer between `1` and `imax`.```

example

````X = randi(imax,n)` returns an `n`-by-`n` matrix of pseudorandom integers drawn from the discrete uniform distribution on the interval [`1`,`imax`].```

example

````X = randi(imax,sz1,...,szN)` returns an `sz1`-by-...-by-`szN` array where `sz1,...,szN` indicate the size of each dimension. For example, `randi(10,3,4)` returns a 3-by-4 array of pseudorandom integers between 1 and 10.```

example

````X = randi(imax,sz)` returns an array where size vector `sz` defines `size(X)`. For example, `randi(10,[3 4])` returns a 3-by-4 array of pseudorandom integers between 1 and 10.```

example

````X = randi(___,typename)` returns an array of pseudorandom integers between `1` and `imax` of data type `typename`. The `typename` input can be `"single"`, `"double"`, `"int8"`, `"uint8"`, `"int16"`, `"uint16"`, `"int32"`, or `"uint32"`. You can use any of the input arguments in the previous syntaxes.```

example

````X = randi(___,"like",p)` returns an array of pseudorandom integers like `p`; that is, with the same data type and complexity (real or complex) as `p`. You can specify either `typename` or `"like"`, but not both.```
````X = randi([imin,imax],___)` returns an array containing integers drawn from the discrete uniform distribution on the interval [`imin`,`imax`], using any of the above syntaxes.```
````X = randi(s,___)` generates integers from random number stream `s` instead of the default global stream. To create a stream, use `RandStream`. You can specify `s` followed by any of the input argument combinations in previous syntaxes.```

## Examples

collapse all

Generate a 5-by-5 matrix of random integers between 1 and 10. The first input to `randi` indicates the largest integer in the sampling interval (the smallest integer in the interval is 1).

`r = randi(10,5)`
```r = 5×5 9 1 2 2 7 10 3 10 5 1 2 6 10 10 9 10 10 5 8 10 7 10 9 10 7 ```

Generate a 10-by-1 column vector of uniformly distributed random integers from the sample interval `[-5,5]`.

`r = randi([-5,5],10,1)`
```r = 10×1 3 4 -4 5 1 -4 -2 1 5 5 ```

Save the current state of the random number generator and create a 1-by-5 vector of random integers.

```s = rng; r = randi(10,1,5)```
```r = 1×5 9 10 2 10 7 ```

Restore the state of the random number generator to `s`, and then create a new 1-by-5 vector of random integers. The values are the same as before.

```rng(s); r1 = randi(10,1,5)```
```r1 = 1×5 9 10 2 10 7 ```

Create a 3-by-2-by-3 array of uniformly distributed random integers between 1 and 500.

`X = randi(500,[3,2,3])`
```X = X(:,:,1) = 408 457 453 317 64 49 X(:,:,2) = 140 483 274 79 479 486 X(:,:,3) = 479 71 243 211 401 458 ```

Create a 1-by-4 vector of random numbers between 1 and 100 whose elements are of type `int16`.

`r = randi(100,1,4,"int16")`
```r = 1x4 int16 row vector 82 91 13 92 ```
`class(r)`
```ans = 'int16' ```

Create a matrix of uniformly distributed random integers between 1 and 10 with the same size as an existing array.

```A = [3 2; -2 1]; sz = size(A); X = randi(10,sz)```
```X = 2×2 9 2 10 10 ```

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

`X = randi(10,size(A));`

Create a 2-by-2 matrix of 8-bit signed integers.

`p = int8([3 2; -2 1]);`

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

`X = randi(10,size(p),"like",p)`
```X = 2x2 int8 matrix 9 2 10 10 ```
`class(X)`
```ans = 'int8' ```

Generate 10 random complex integers from the discrete uniform distribution over a square domain with real and imaginary parts in the interval `[-5,5]`.

`a = randi([-5,5],10,1,"like",1i)`
```a = 10×1 complex 3.0000 + 4.0000i -4.0000 + 5.0000i 1.0000 - 4.0000i -2.0000 + 1.0000i 5.0000 + 5.0000i -4.0000 + 5.0000i 5.0000 + 0.0000i 3.0000 - 4.0000i -1.0000 + 5.0000i 3.0000 + 5.0000i ```

## Input Arguments

collapse all

Largest integer in sample interval, specified as a positive integer. `randi` draws values from the uniform distribution in the sample interval `[1,imax]`.

Example: `randi(10,5)`

Smallest integer in sample interval, specified as a scalar integer.

Both `imin` and `imax` must be integers that satisfy `imin``imax`.

For example, `randi([50,100],5)` returns a 5-by-5 matrix of random integers between (and including) 50 and 100.

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: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

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, `randi` ignores trailing dimensions with a size of 1. For example, `randi([5,10],3,1,1,1)` produces a 3-by-1 vector of random integers between 5 and 10.

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

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, `randi` ignores trailing dimensions with a size of 1. For example, `randi([5,10],[3 1 1 1])` produces a 3-by-1 vector of random integers between 5 and 10.

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

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

Example: `randi(5,5,"int8")`

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

Example: `randi(5,5,"like",p)`

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

Random number stream, specified as a `RandStream` object.

Example: ```s = RandStream("dsfmt19937"); randi(s,[5,10],[3 1])```

## Tips

• The sequence of numbers produced by `randi` is determined by the internal settings of the uniform pseudorandom number generator that underlies `rand`, `randi`, and `randn`. You can control that shared random number generator using `rng`.

• The arrays returned by `randi` can contain repeated integer values. This behavior is sometimes referred to as sampling with replacement. Use `randperm` if you require all unique values.

## Version History

Introduced in R2008b

expand all