Pseudorandom Numbers

Mathematica has three functions for generating pseudorandom numbers that are distributed uniformly over a range of values.

RandomInteger[]0 or 1 with probability
RandomInteger[{imin,imax}]an integer between and , inclusive
RandomInteger[imax]an integer between 0 and , inclusive
RandomReal[ ]a real number between 0 and 1
RandomReal[{x_(min), x_(max)}]a real number between and
RandomReal[x_(max)]a real number between 0 and
RandomComplex[]a complex number in the unit square
RandomComplex[{zmin,zmax}]a complex number in the rectangle defined by and
RandomComplex[z_(max)]a complex number in the rectangle defined by 0 and

Pseudorandom number generation.

RandomReal[range,n],RandomComplex[range,n],RandomInteger[range,n]
a list of n pseudorandom numbers from the given range
RandomReal[range,{n1,n2,...}],RandomComplex[range,{n1,n2,...}],RandomInteger[range,{n1,n2,...}]
an ××... array of pseudorandom numbers

Generating tables of pseudorandom numbers.

This will give 0 or 1 with equal probability.
In[1]:=
Click for copyable input
Out[1]=
This gives a pseudorandom complex number.
In[2]:=
Click for copyable input
Out[2]=
This gives a list of 10 pseudorandom integers between 0 and 9 (inclusive).
In[3]:=
Click for copyable input
Out[3]=
This gives a matrix of pseudorandom reals between 0 and 1.
In[4]:=
Click for copyable input
Out[4]=

RandomReal and RandomComplex allow you to obtain pseudorandom numbers with any precision.

option name
default value
WorkingPrecisionMachinePrecisionprecision to use for real or complex numbers

Changing the precision for pseudorandom numbers.

Here is a 30-digit pseudorandom real number in the range 0 to 1.
In[5]:=
Click for copyable input
Out[5]=
Here is a list of four 20-digit pseudorandom complex numbers.
In[6]:=
Click for copyable input
Out[6]=

If you get arrays of pseudorandom numbers repeatedly, you should get a "typical" sequence of numbers, with no particular pattern. There are many ways to use such numbers.

One common way to use pseudorandom numbers is in making numerical tests of hypotheses. For example, if you believe that two symbolic expressions are mathematically equal, you can test this by plugging in "typical" numerical values for symbolic parameters, and then comparing the numerical results. (If you do this, you should be careful about numerical accuracy problems and about functions of complex variables that may not have unique values.)

Here is a symbolic equation.
In[7]:=
Click for copyable input
Out[7]=
Substituting in a random numerical value shows that the equation is not always True.
In[8]:=
Click for copyable input
Out[8]=

Other common uses of pseudorandom numbers include simulating probabilistic processes, and sampling large spaces of possibilities. The pseudorandom numbers that Mathematica generates for a range of numbers are always uniformly distributed over the range you specify.

RandomInteger, RandomReal, and RandomComplex are unlike almost any other Mathematica functions in that every time you call them, you potentially get a different result. If you use them in a calculation, therefore, you may get different answers on different occasions.

The sequences that you get from RandomInteger, RandomReal, and RandomComplex are not in most senses "truly random", although they should be "random enough" for practical purposes. The sequences are in fact produced by applying a definite mathematical algorithm, starting from a particular "seed". If you give the same seed, then you get the same sequence.

When Mathematica starts up, it takes the time of day (measured in small fractions of a second) as the seed for the pseudorandom number generator. Two different Mathematica sessions will therefore almost always give different sequences of pseudorandom numbers.

If you want to make sure that you always get the same sequence of pseudorandom numbers, you can explicitly give a seed for the pseudorandom generator, using SeedRandom.

SeedRandom[]reseed the pseudorandom generator, with the time of day
SeedRandom[s]reseed with the integer s

Pseudorandom number generator seed.

This reseeds the pseudorandom generator.
In[9]:=
Click for copyable input
Here are three pseudorandom numbers.
In[10]:=
Click for copyable input
Out[10]=
If you reseed the pseudorandom generator with the same seed, you get the same sequence of pseudorandom numbers.
In[11]:=
Click for copyable input
Out[11]=

Every single time RandomInteger, RandomReal, or RandomComplex is called, the internal state of the pseudorandom generator that it uses is changed. This means that subsequent calls to these functions made in subsidiary calculations will have an effect on the numbers returned in your main calculation. To avoid any problems associated with this, you can localize this effect of their use by doing the calculation inside of BlockRandom.

BlockRandom[expr]evaluates expr with the current state of the pseudorandom generators localized

Localizing the effects of using RandomInteger, RandomReal, or RandomComplex.

By localizing the calculation inside BlockRandom, the internal state of the pseudorandom generator is restored after generating the first list.
In[12]:=
Click for copyable input
Out[12]=

Many applications require random numbers from non-uniform distributions. Mathematica has many distributions built into the system. You can give a distribution with appropriate parameters instead of a range to RandomInteger or RandomReal.

RandomInteger[dist],RandomReal[dist]
a pseudorandom number distributed by the random distribution dist
RandomInteger[dist,n],RandomReal[dist,n]
a list of n pseudorandom numbers distributed by the random distribution dist
RandomInteger[dist,{n1,n2,...}],RandomReal[dist,{n1,n2,...}]
an ××... array of pseudorandom numbers distributed by the random distribution dist

Generating pseudorandom numbers with non-uniform distributions.

This generates 12 integers distributed by the Poisson distribution with mean 3.
In[13]:=
Click for copyable input
Out[13]=
This generates a 4×4 matrix of real numbers using the standard normal distribution.
In[14]:=
Click for copyable input
Out[14]=
This generates five high-precision real numbers distributed normally with mean 2 and standard deviation 4.
In[15]:=
Click for copyable input
Out[15]=

An additional use of pseudorandom numbers is for selecting from a list. RandomChoice selects with replacement and RandomSample samples without replacement.

RandomChoice[list, n]choose n items at random from list
RandomChoice[list,{n1,n2,...}]an ××... array of values chosen randomly from list
RandomSample[list, n]a sample of size n from list

Selecting at random.

Choose 10 items at random from the digits 0 through 9.
In[16]:=
Click for copyable input
Out[16]=

Chances are very high that at least one of the choices was repeated in the output. That is because when an element is chosen, it is immediately replaced. On the other hand, if you want to select from an actual set of elements, there should be no replacement.

Sample 10 items at random from the digits 0 through 9 without replacement. The result is a random permutation of the digits.
In[17]:=
Click for copyable input
Out[17]=
Sample 10 items from a set having different frequencies for each digit.
In[18]:=
Click for copyable input
Out[18]=
New to Mathematica? Find your learning path »
Have a question? Ask support »