rand - Uniformly distributed random numbers

rand - Uniformly distributed random numbers - MATLAB

Uniformly distributed random numbers

Syntax

Description

X = rand returns a random scalar drawn from the uniform distribution in the interval (0,1).

X = rand(n) returns an n-by-n matrix of uniformly distributed random numbers.

X = rand(sz1,...,szN) returns an sz1-by-...-by-szN array of random numbers where sz1,...,szN indicate the size of each dimension. For example, rand(3,4) returns a 3-by-4 matrix.

example

X = rand(sz) returns an array of random numbers where size vector sz defines size(X). For example, rand([3 4]) returns a 3-by-4 matrix.

example

X = rand(___,typename) returns an array of random numbers of data type typename. The typename input can be either "single" or "double". You can use any of the input arguments in the previous syntaxes.

example

X = rand(___,like=p) returns an array of random numbers like p; that is, of the same data type and complexity (real or complex) as p. You can specify either typename or like, but not both.

example

X = rand(s,___) generates numbers 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 uniformly distributed random numbers between 0 and 1.

r = 5×5

    0.8147    0.0975    0.1576    0.1419    0.6557
    0.9058    0.2785    0.9706    0.4218    0.0357
    0.1270    0.5469    0.9572    0.9157    0.8491
    0.9134    0.9575    0.4854    0.7922    0.9340
    0.6324    0.9649    0.8003    0.9595    0.6787

Generate a 10-by-1 column vector of uniformly distributed numbers in the interval (-5,5). You can generate n random numbers in the interval (a,b) with the formula r = a + (b-a).*rand(n,1).

a = -5;
b = 5;
n = 10;
r = a + (b-a).*rand(n,1)

Use the randi function (instead of rand) to generate 5 random integers from the uniform distribution between 10 and 50.

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

r = 1×5

    0.8147    0.9058    0.1270    0.9134    0.6324

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

r1 = 1×5

    0.8147    0.9058    0.1270    0.9134    0.6324

Create a 3-by-2-by-3 array of random numbers.

X = 
X(:,:,1) =

    0.8147    0.9134
    0.9058    0.6324
    0.1270    0.0975


X(:,:,2) =

    0.2785    0.9649
    0.5469    0.1576
    0.9575    0.9706


X(:,:,3) =

    0.9572    0.1419
    0.4854    0.4218
    0.8003    0.9157

Create a 1-by-4 vector of random numbers whose elements are single precision.

r = 1×4 single row vector

    0.8147    0.9058    0.1270    0.9134

Create a matrix of uniformly distributed random numbers with the same size as an existing array.

A = [3 2; -2 1];
sz = size(A);
X = rand(sz)

X = 2×2

    0.8147    0.1270
    0.9058    0.9134

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

Create a 2-by-2 matrix of single-precision random numbers.

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

X = 2×2 single matrix

    0.8147    0.1270
    0.9058    0.9134

Generate 10 random complex numbers from the uniform distribution over a square domain with real and imaginary parts in the interval (0,1).

a = 10×1 complex

   0.8147 + 0.9058i
   0.1270 + 0.9134i
   0.6324 + 0.0975i
   0.2785 + 0.5469i
   0.9575 + 0.9649i
   0.1576 + 0.9706i
   0.9572 + 0.4854i
   0.8003 + 0.1419i
   0.4218 + 0.9157i
   0.7922 + 0.9595i

Input Arguments

collapse all

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.

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, rand ignores trailing dimensions with a size of 1. For example, rand(3,1,1,1) produces a 3-by-1 vector of random numbers.

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, rand ignores trailing dimensions with a size of 1. For example, rand([3 1 1 1]) produces a 3-by-1 vector of random numbers.

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

Data type (class) to create, specified as "double", "single", or the name of another class that provides rand support.

Example: rand(5,"single")

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

Example: rand(5,like=p)

Data Types: single | double
Complex Number Support: Yes

Random number stream, specified as a RandStream object.

Example: s = RandStream("dsfmt19937"); rand(s,[3 1])

Output Arguments

collapse all

Output array, returned as a scalar, vector, matrix, or multidimensional array.

More About

collapse all

The underlying number generator for rand is a pseudorandom number generator, which creates a deterministic sequence of numbers that appear random. These numbers are predictable if the seed and the deterministic algorithm of the generator are known. While not truly random, the generated numbers pass various statistical tests of randomness, satisfying the independent and identically distributed (i.i.d.) condition, and justifying the name pseudorandom.

Tips

The sequence of numbers produced by rand 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.

Extended Capabilities

expand all

Usage notes and limitations:

If used, the input argument typename must be "double","single", "int8", "uint8", "int16", "uint16", "int32", "uint32", or "logical". Other classes are not supported, even if the class defines a static rand method.
If used, size arguments n, sz, and sz1,...,szN must be fixed size.
The code generator uses double-precision math to compute single-precision outputs.
In most cases, generated MEX files use the same random number state as MATLAB^®. If you disable extrinsic calls or you call rand from inside a parfor-loop, the generated MEX code and standalone code maintain their own random number state that is initialized to the MATLAB default, which is rng(0,"twister").

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

You can specify typename as 'gpuArray'. If you specify typename as 'gpuArray', the default underlying type of the array is double.
To create a GPU array with underlying type datatype, specify the underlying type as an additional argument before typename. For example, X = rand(3,datatype,'gpuArray') creates a 3-by-3 GPU array of random numbers with underlying type datatype.
You can specify the underlying type datatype as one of these options:
- 'double'
- 'single'
You can also specify the numeric variable p as a gpuArray.
If you specify p as a gpuArray, the underlying type of the returned array is the same as p.
To use the stream syntax, rand(s,___), on a GPU, s must be a parallel.gpu.RandStream (Parallel Computing Toolbox) object.

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

Usage notes and limitations:

The stream syntax rand(s,___) is not supported for codistributed or distributed arrays.
You can specify typename as 'codistributed' or 'distributed'. If you specify typename as 'codistributed' or 'distributed', the default underlying type of the returned array is double.
To create a distributed or codistributed array with underlying type datatype, specify the underlying type as an additional argument before typename. For example, X = rand(3,datatype,'distributed') creates a 3-by-3 distributed matrix of random numbers with underlying type datatype.
You can specify the underlying type datatype as one of these options:
- 'double'
- 'single'
You can also specify p as a codistributed or distributed array.
If you specify p as a codistributed or distributed array, the underlying type of the returned array is the same as p.
For additional codistributed syntaxes, see rand (codistributed) (Parallel Computing Toolbox).

For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Version History

Introduced before R2006a

expand all

The like name-value argument supports both real and complex prototype arrays. For example:

r =

   0.8147 + 0.9058i   0.6324 + 0.0975i
   0.1270 + 0.9134i   0.2785 + 0.5469i

All syntaxes support this feature. Also, you can now use like with a RandStream object as the first input of rand.

To generate random numbers with the same data type as an existing variable, use the syntax rand(__,'like',p). For example:

A = single(pi);
r = rand(4,4,'like',A);
class(r)

This feature is not available when passing a RandStream object as the first input to rand.

Specifying a dimension that is not an integer causes an error. Use floor to convert non-integer size inputs to integers.

There are no plans to remove these inputs, which control the random number generator that underlies rand, randi and randn. However, the rng function is recommended instead for these reasons:

The 'seed' and 'state' generators are flawed.
The terms 'seed' and 'state' are misleading names for the generators. 'seed' refers to the MATLAB v4 generator, not the seed initialization value. 'state' refers to the v5 generators, not the internal state of the generator.
These three inputs unnecessarily use different generators for rand and randn.

For information on updating your code, see Replace Discouraged Syntaxes of rand and randn.