Work with Random Generators

All Products Maple MapleSim

Home : Support : Online Help : Getting Started : How Do I... : Work with Random Generators

How Do I

Work with Random Generators?

Maple provides different methods for efficiently generating random numbers (floats, integers, and rational numbers), rtables (Arrays, Matrices, and Vectors) with random entries, graphs, logic, and more. This page suggests the best commands available for such purposes.

To interact with the examples shown on this page, open it as worksheet and execute the steps.

Array (Integer Entries)

Array (Float Entries)

Array (From a Distribution)

Matrix (Integer Entries)

Matrix (Float Entries)

Matrix (From a Given Distribution)

Integer

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

rand - is the simplest command to generate random integers sampled uniformly from the range $0$ to $10^{12} - 1$ and has a period of $2^{19937} - 1$ . It calls RandomTools[MersenneTwister][GenerateInteger] or RandomTools[MersenneTwister][NewGenerator] depending on whether or not a number or procedure is to be returned.

In order to vary the numbers generated, you can call randomize(n) where n (a positive integer) will set the initial state. With no arguments, randomize() will use a number based on the system clock as the initial state.

$restart$

Returns a single random integer:

$rand ()$

$959740139875$

(1.1)

A procedure that can generate integers from a specified range:

>	$R ≔ rand (100 .. 200) &colon;$

$R ()$

$192$

(1.2)

$R ()$

$144$

(1.3)

Returns a sequence of random numbers using:

>	$seq (R (), i = 1 .. 5)$

$144, 195, 105, 197, 158$

(1.4)

Other available commands to generate random integers:

•	RandomTools[MersenneTwister][GenerateInteger] - uses the MersenneTwister algorithm that is implemented in the kernel. The length of the output depends on the value of the range option, that is [0, value), otherwise the default is $10^{12}$ .

•	RandomTools[MersenneTwister][NewGenerator] - the procedure used to return numerous integers at once.

•	RandomTools[MersenneTwister][GenerateInteger32] - uses the MersenneTwister algorithm to generate a signed 32-bit random integer.

•	RandomTools[MersenneTwister][GenerateUnsignedInt32] - uses the MersenneTwister algorithm to generate an unsigned 32-bit random integer.

•	RandomTools[LinearCongruence][GenerateInteger] - uses the LinearCongruence algorithm and is ideal for educational purposes. The length of output depends on the value of the range option, that is [0, value), otherwise the default is $10^{12}$ .

•	RandomTools[Generate] - this command recognizes several flavors that return integers. The following is a list of these flavors that can be used depending on the type of output desired: integer, posint, negint, nonnegint, nonposint, and nonzeroint.

•

rand

Return to the top of the page

Float

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

RandomTools[MersenneTwister][GenerateFloat] -

generates a pseudo-random float uniformly distributed in [0,1). It uses the MersenneTwister algorithm that is implemented in the kernel and is extremely fast.

The MersenneTwister algorithm is intended to be used as a general purpose random number generator. It is good for randomized algorithm and generating random data and has a period of $2^{19937} - 1$ .

$restart$

>	$with (RandomTools [MersenneTwister]) &colon;$

>	$GenerateFloat ()$

$0.0581869302$

(2.1)

Uses the digits=integer option to specify how many random digits should be returned:

>	$GenerateFloat (digits = 5)$

$0.13612$

(2.2)

Other available commands to generate random floats are:

•	RandomTools[MersenneTwister][GenerateFloat64] - uses the MersenneTwister algorithm to generate a pseudo-random float[8] value that is uniformly distributed in [0,1).

•	Random[Generate(float)], where float is one of the many flavors recognized by the Generate command.

Return to the top of the page

Rational

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

RandomTools[Generate](rational) - uses the flavor rational for the Generate command to output rational numbers.

Generate creates a particular random object that is determined by the flavor and data structures of the parameters chosen or combinations of them. The underlying procedure of this command is based on the Mersenne Twister algorithm that has a period of $2^{19937} - 1$ .

For a list of Maple types, flavor templates, and data structures that are recognized by Generate, see RandomTools[Generate].

$restart$

>	$with (RandomTools) &colon;$

>	$Generate (rational)$

$- \frac{104281139459}{499999999994}$

(3.1)

>	$Generate (rational (range = \frac{1}{4} .. \frac{3}{4}, character = open .. closed, denominator = 53000))$

$\frac{7799}{26500}$

(3.2)

>	$Matrix (3, 3, Generate (rational (denominator = 24) &ast; identical (x) + rational (denominator = 16), makeproc = true)) &semi;$

RandomTools[Generate] recognizes several other flavors that return rational numbers. The following is a list of these flavors that can be used depending on the type of output desired:

positive, negative, nonnegative, nonpositive, and nonzero.

Return to the top of the page

Random Data Sample

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

Statistics[Sample] - this function takes a probability distribution (see Statistics[Distributions]), a random variable, or an algebraic expression involving random variables (see Statistics[RandomVariable]) and creates a Vector, Matrix, or Array containing the sample values. Outputs of the Sample command are random floats by default.

$restart$

>	$with (Statistics) &colon;$

>	$Sample (Normal (0, 1), 3)$

>	$Sample (Uniform (0, 1), 1) [1]$

$0.913375856139019$

(4.1)

Other available functions to generate random data sample (float):

•	This function is also featured in the Students package under Student[Statistics][Sample].

•	RandomTools[Generate(distribution)], where distribution is one of the many flavors recognized by the Generate command.

Return to the top of the page

Polynomials

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

randpoly - a random polynomial generator, useful for generating test problems for debugging, testing, and demonstration purposes. The default range of the coefficients generated is $- 99 .. 99$ .

$restart$

>	$randpoly (x)$

$- 7 x^{5} + 22 x^{4} - 55 x^{3} - 94 x^{2} + 87 x - 56$

(5.1)

Random homogeneous polynomial:

>	$randpoly ([x, y])$

$- 75 x^{4} y - 17 x^{2} y + 80 x^{2} - 44 x y + 71 y^{2} - 82 x$

(5.2)

Use various options, such as coeffs, expons, terms, degree, dense, and homogeneous in order to return appropriate outputs. For example:

>	$randpoly ([x, y], degree = 4, terms = 6, dense)$

$- 23 x^{4} + 87 x^{3} y + 29 x^{2} y^{2} + 10 x y^{3} + 95 y^{4} + 44 x^{3} + 98 x^{2} y - 61 x y^{2} + 11 y^{3} - 23 x^{2} - 8 x y - 49 y^{2} - 29 x - 47 y + 40$

(5.3)

Other available commands to generate random polynomials are:

•	Randpoly - generates a random polynomial over a finite field.

•	Randprime - generates a random, monic, prime polynomial over a finite field.

•	RandomTools[Generate(polynom)], where polynom is one of the many flavors recognized by the Generate command.

Return to the top of the page

Array (Integer Entries)

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

Array - use the optional parameter random to generate Arrays with random integer entries. The default range for random is all possible integers.

$restart$

An Array of five integers from a given range:

>	$Array (1 .. 5, random (0 .. 10))$

Create a random Array of $n$ -byte hardware integer, where $n$ is one of $1$ , $2$ , $4$ , or $8$ :

>	$Array (1 .. 5, random (), datatype = integer [1])$

>	$Array (antisymmetric, 1 .. 2, 1 .. 2, random ())$

Alternatively, use rtable to generate random Arrays with integer, float, and complex entries by specifying the datatype as integer[n], float[n], and complex[n], respectively.

Return to the top of the page

Array (Float Entries)

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

Array - use the optional parameter frandom to generate Arrays with random floating-point entries. The default range for frandom is $0 .. 1$ .

$restart$

>	$Array (1 .. 5, frandom ())$

range=0..0.5:

>	$Array (1 .. 5, frandom (0 .. 0.5))$

Alternatively, use rtable to generate random Arrays with integer, float, and complex entries by specifying the datatype as integer[n], float[n], and complex[n], respectively.

Return to the top of the page

Array (From a Distribution)

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

ArrayTools[RandomArray] - the RandomArray(m, n, o, ...) and RandomArray(m, n, o, ..., distribution = uniform) calls randomly generate an m-by-n-by-o-by-... array of values (floats) drawn from a uniform distribution. RandomArray(m, n, o, ..., distribution = normal) call draws values (floats) from a normal distribution to create an m-by-n-by-o-by-... array.

$restart$

>	$with (ArrayTools) &colon;$

>	$RandomArray ()$

$0.2342493224$

(8.1)

>	$T ≔ RandomArray (2, 4, 6, 7)$

Number of elements in the array:

>	$numelems (T)$

$336$

(8.2)

>	$RandomArray (1, 2, distribution = normal)$

>	$A ≔ RandomArray (2, 1, 3, 6, 4, distribution = normal)$

>	$numelems (A)$

$144$

(8.3)

Other available commands to generate random arrays are:

•	Statistics[Sample] - generates random sample, where the parameter, rng, is a range or a list of ranges determining the dimensions of an Array. This Array will be created, filled with the sample values, and returned.

•	Alternatively, this function is also featured in the Students package under Student[Statistics][Sample].

Return to the top of the page

Matrix (Integer Entries)

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

LinearAlgebra[RandomMatrix] - this function returns an $m \times n$ random matrix where all the entries are integers in the range of $- 99 .. 99$ and has a period of $2^{19937} - 1$ .

$restart$

>	$with (LinearAlgebra) &colon;$

Create an $m \times n$ random matrix:

>	$RandomMatrix (3, 2)$

>	$RandomMatrix (3, 3, shape = diagonal)$

Where shape=diagonal is one of the built-in indexing functions for Matrices. See Matrix for details.

Other available commands to construct a Matrix with random integers are:

•	This function is also featured in the Students package under Student[LinearAlgebra][RandomMatrix].

•	RandomTools[Generate(Matrix)], where Matrix is one of the many flavors recognized by the Generate command. The default flavor of each entry is integer.

Return to the top of the page

Matrix (Float Entries)

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

ArrayTools[RandomArray] - calls to return an $m \times n$ matrix where entries are random floats.

$restart$

>	$with (ArrayTools) &colon;$

Generate a 3-by-3 matrix of values:

>	$RandomArray (3)$

The above is equivalent to calling: $RandomArray (3, distribution = uniform)$ .

Generate a 3-by-2 Matrix using normal distribution:

>	$RandomArray (3, 2, distribtion = normal)$

Other available commands to construct a Matrix with random floats are:

•	ArrayTools[RandomArray]

•	RandomTools[Generate] - by combining flavors Matrix and distribution.

Return to the top of the page

Matrix (From a Given Distribution)

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

$restart$

>	$with (Statistics) &colon;$

Generate a 3-by-3 Matrix using Normal distribution:

>	$M ≔ Sample (Normal (0, 1), [3, 3])$

Other available commands to construct a Matrix with random floats are:

•	This function is also featured in the Students package under Student[Statistics][Sample].

•	RandomTools[Generate] - by combining flavors Matrix and distribution. (CPU time=5.16 ms)

Return to the top of the page

Vector

Recommended Command

Examples

Notes (links to other commands with same functionality) / Other Available Commands

LinearAlgebra[RandomVector] - constructs a random Vector. The entries returned are integers in the range of $- 99 .. 99$ and has a period of $2^{19937} - 1$ .

$restart$

>	$with (LinearAlgebra) &colon;$

Random vector with integer entries:

>	$RandomVector (3, generator = 1 .. 9)$

>	$RandomVector [row] (3, generator = rand (1 .. 10))$

Random vector with float entries:

>	$RandomVector (3, generator = 0.1 .. 0.9)$

•	This function is also featured in the Students package under Student[LinearAlgebra][RandomVector].

•	RandomTools[Generate(Vector)], where Vector is one of the many flavors recognized by the Generate command. The default flavor of each entry is integer.

Return to the top of the page

List

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

RandomTools[Generate(list)] - uses the flavor list for the Generate command to return a list of random objects, which are specified by other flavors.

$restart$

>	$with (RandomTools) &colon;$

List of random integers:

>	$Generate (list (integer, 3))$

$[- 104281139460, - 306860183579, - 477575829529]$

(13.1)

List of random floats:

>	$Generate (list (float, 2))$

$[8.344539878 10^{-7}, 8.412421905 10^{-10}]$

(13.2)

List of Matrices with integer entries:

>	$Generate (list (' Matrix' (integer, 2, 2), 2))$

Use flav=listlist to generate a list of lists:

>	$Generate (listlist (rational, 2))$

$[[\frac{236602622351}{499999999994}, - \frac{170155408191}{499999999994}], [\frac{10521097205}{45454545454}, \frac{347018765395}{499999999994}]]$

(13.3)

>	$Generate (listlist (integer (range = 1 .. 10), 3, 2))$

$[[7, 7], [3, 3], [5, 3]]$

(13.4)

For a complete list of Maple types, flavors, templates, and data structures that can be combined with flav=list, see RandomTools[Generate].

Return to the top of the page

Set

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

RandomTools[Generate(set)] - uses the flavor set to generate a set of random objects.

$restart$

>	$with (RandomTools) &colon;$

Set of random positive integers:

>	$Generate (set (posint, 3))$

$\{33467275626, 57646025778, 79394083865\}$

(14.1)

Generate a set of random negative integers:

>	$Generate (set (negint (range = - 10), 3))$

$\{- 8, - 4\}$

(14.2)

where, n=3 is the maximum number of entries in the set.

Set of Vectors with nonzero rational entries:

>	$Generate (set (' Vector' (nonzero (range = - 5 .. 5), 2), 2))$

For a complete list of Maple types, flavors, templates, and data structures that can be combined with flav=set, see RandomTools[Generate].

Return to the top of the page

Permutation

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

combinat[randperm] - construct a random permutation.

$restart$

>	$with (combinat) &colon;$

Return a random permutation of n=5 positive integers:

>	$randperm (5)$

$[3, 4, 5, 1, 2]$

(15.1)

Random permutation from a list:

>	$randperm ([5, 7, 9, 10, 12])$

$[7, 9, 12, 10, 5]$

(15.2)

Or, from a set:

>	$randperm (\{a, b, c, d, e\})$

$[a, c, b, d, e]$

(15.3)

You can also generate something like the following:

>	$players ≔ randperm ([U, V, W, X, Y, Z]) &colon;$

>	$teams ≔ players [1 .. 3], players [4 ..]$

$teams := [V, Y, Z], [X, U, W]$

(15.4)

Return to the top of the page

Combination

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

combinat[randcomb] - returns a random combination of elements.

$restart$

>	$with (combinat) &colon;$

Returns a random combination of five of the first 15 integers:

>	$randcomb (15, 5)$

$\{6, 7, 10, 13, 15\}$

(16.1)

Random combination of three elements from a given list:

>	$randcomb ([a, b, c, d, e], 3)$

$[a, d, e]$

(16.2)

Or, from a given set:

>	$randcomb (\{4, 5, 6, 7, 8, 9\}, 3)$

$\{7, 8, 9\}$

(16.3)

You can also generate something like the following:

>	$cards ≔ [seq (op ([cat (s, 1 .. 10), cat (s, Jack), cat (s, Queen), cat (s, King), cat (s, Ace)]), s in [Heart, Club, Spade, Diamond])] &colon;$

>	$hand ≔ randcomb (cards, 5)$

$hand := [Club3, ClubKing, Spade4, Spade9, SpadeQueen]$

(16.4)

Return to the top of the page

Random Partition

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

combinat[randpart] - computes and returns a list of random partition of a positive integer n, where the sum of each element in the list equals n.

$restart$

>	$with (combinat) &colon;$

Return a list of random partition for n=5:

>	$randpart (5)$

$[2, 3]$

(17.1)

You can check the list of all possible partitions for a given n=5 as follows:

>	$partition (5)$

$[[1, 1, 1, 1, 1], [1, 1, 1, 2], [1, 2, 2], [1, 1, 3], [2, 3], [1, 4], [5]]$

(17.2)

Return to the top of the page

Logic

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

Logic[Random] - generates a random Boolean function. The default form is a disjunctive normal form (DNF).

$restart$

>	$with (Logic) &colon;$

>	$Random (\{a, b, c\}, form = MOD2)$

$a b + b c + a + b$

(18.1)

Use % to evaluate the last expression as follows:

>	$eval (%, \{a = 1, b = 0, c = 1\}) mod 2$

$1$

(18.2)

>	$Random ([a, b, c], form = MOD2)$

$a b c + a b + a c$

(18.3)

>	$Random (\{a, b\})$

$a &and b &or &not (a) &and &not (b)$

(18.4)

Random Boolean with conjunctive normal form:

>	$Random ([a, b], form = CNF)$

$(a &or b) &and (&not (a) &or &not (b))$

(18.5)

Return to the top of the page

String

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

StringTools[Random] - generates a random string.

$restart$

>	$with (StringTools) &colon;$

Return a string of length len=20:

>	$Random (20,' alpha')$

$mxYYTxRAPYLRkyzmiKLE$

(19.1)

where characters are chosen from the letters A-Z or a-z with equal probability.

The following call restricts the characters returned to uppercase letters (alphabet=upper):

>	$Random (20,' upper')$

$KNGKYYTRAPYLRKLELFAM$

(19.2)

Or, returns 20 random lowercase letters:

>	$Random (20,' lower')$

$glqpxdsfarkdmjgrtqiw$

(19.3)

Generate a random word:

>	$words ≔ EssayTools :- GetWordList () &colon;$

>	$R ≔ rand (1 .. numelems (words)) &colon;$

>	$words [R ()]$

$spark$

(19.4)

For a list of character class names recognized by alphabet, see StringTools[Random].

For more information on generating random words, see EssayTools[GetWordList].

Return to the top of the page

Graph

Recommended Command

Examples

Notes (links to other commands with the same functionality) / Other Available Commands

GraphTheory[RandomGraphs][RandomGraph] - uses the calls RandomGraph(n,p) and RandomGraph(n,m) to create undirected, unweighted graphs. Options such as directed and weights can be added to these calls to generate directed and weighted graphs, respectively.

$restart$

>	$with (GraphTheory) &colon;$

>	$with (GraphTheory [RandomGraphs]) &colon;$

Create an undirected, unweighted graph with n=5 vertices and probability p=0.5:

>	$G ≔ RandomGraph (5, 0.5)$

$G := Graph 4: an undirected unweighted graph with 5 vertices and 7 edge(s)$

(20.1)

>	$DrawGraph (G)$

Alternatively, carry out the one-step execution:

>	$DrawGraph (RandomGraph (5, 0.5))$

A random, unweighted graph with n=8 vertices and m=10 edges:

>	$DrawGraph (RandomGraph (8, 10))$

The following specification can only return one form:

>	$DrawGraph (RandomGraph (5, 10))$

Use RandomGraph(n, m, option=directed) to create a random, directed graph:

>	$DrawGraph (RandomGraph (8, 10, directed))$

For other routines that generate random graphs with particular properties or structures, see the GraphTheory[RandomGraphs] subpackage.

Return to the top of the page

Maple

Maple 附加模块

Student Success Platform

提高存留率

MapleSim

MapleSim 附加模块

系统工程

项目服务

Maple T.A. and Möbius

教育

行业

汽车与航空航天

机器人

机器设计和工业自动化

其他

应用领域

产品价格

购买

院系/全校正版授权

Maplesoft精英维护升级计划

支持

产品培训

产品在线帮助

研讨会与活动

出版

资源中心

示例和应用

社区

关于 Maplesoft

媒体中心

用户社区

联系我们

Online Help

All Products Maple MapleSim

Maple

数学软件

Maple 附加模块

Student Success Platform

提高存留率

MapleSim

多学科系统级建模仿真

MapleSim 附加模块

系统工程

项目服务

Maple T.A. and Möbius

教育

行业

汽车与航空航天

机器人

机器设计和工业自动化

其他

应用领域

产品价格

购买

院系/全校正版授权

Maplesoft精英维护升级计划

支持

产品培训

产品在线帮助

研讨会与活动

出版

资源中心

示例和应用

社区

关于 Maplesoft

媒体中心

用户社区

联系我们

Online Help

All Products Maple MapleSim