rand

Nombres aléatoires uniformément distribués

Syntaxe

X = rand

X = rand(n)

X = rand(sz1,...,szN)

X = rand(sz)

X = rand(___,typename)

X = rand(___,like=p)

X = rand(s,___)

Description

X = rand renvoie un scalaire aléatoire tiré de la distribution uniforme dans l’intervalle (0,1).

X = rand(n) renvoie une matrice de nombres aléatoires uniformément distribués de dimension n x n.

X = rand(sz1,...,szN) renvoie un tableau de nombres aléatoires de dimension sz1 x ... x szN où sz1,...,szN indiquent la taille de chaque dimension. Par exemple, rand(3,4) renvoie une matrice 3 x 4.

X = rand(sz) renvoie un tableau de nombres aléatoires où le vecteur de taille sz définit size(X). Par exemple, rand([3 4]) renvoie une matrice 3 x 4.

X = rand(___,typename) renvoie un tableau de nombres aléatoires dont le type de données est typename. L’entrée typename peut être soit "single" soit "double". Vous pouvez utiliser n’importe quel argument en entrée dans les syntaxes précédentes.

X = rand(___,like=p) renvoie un tableau de nombres aléatoires tels que p, c’est-à-dire du même type de données et de la même complexité (réelle ou complexe) que p. Vous pouvez spécifier typename ou like, mais pas les deux.

X = rand(s,___) génère des nombres à partir d’une série de nombres aléatoires s au lieu de la série globale par défaut. Pour créer une série, utilisez RandStream. Vous pouvez spécifier s suivi de n’importe quelle combinaison d’arguments en entrée dans les syntaxes précédentes.

Exemples

Matrice de nombres aléatoires

Générez une matrice 5 x 5 de nombres aléatoires uniformément distribués entre 0 et 1.

r = rand(5)

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

Nombres aléatoires dans un intervalle spécifié

Générez un vecteur colonne de nombres uniformément distribués de dimension 10 x 1 dans l’intervalle (-5,5). Vous pouvez générer n nombres aléatoires dans l’intervalle (a,b) avec la formule r = a + (b-a).*rand(n,1).

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

r = 10×1

    3.1472
    4.0579
   -3.7301
    4.1338
    1.3236
   -4.0246
   -2.2150
    0.4688
    4.5751
    4.6489

Nombres entiers aléatoires

Utilisez la fonction randi (au lieu de rand) pour générer 5 nombres entiers aléatoires à partir de la distribution uniforme entre 10 et 50.

r = randi([10 50],1,5)

r = 1×5

    43    47    15    47    35

Réinitialiser le générateur de nombres aléatoires

Sauvegardez l’état actuel du générateur de nombres aléatoires et créez un vecteur de nombres aléatoires de dimension 1 x 5.

s = rng;
r = rand(1,5)

r = 1×5

    0.8147    0.9058    0.1270    0.9134    0.6324

Restaurez l’état du générateur de nombres aléatoires sur s, puis créez un nouveau vecteur de nombres aléatoires de dimension 1 x 5. Les valeurs sont les mêmes qu’avant.

rng(s);
r1 = rand(1,5)

r1 = 1×5

    0.8147    0.9058    0.1270    0.9134    0.6324

Tableau 3D de nombres aléatoires

Créez un tableau de nombres aléatoires de dimension 3 x 2 x 3.

X = rand([3,2,3])

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

Spécifier le type de données des nombres aléatoires

Créez un vecteur de nombres aléatoires de dimension 1 x 4 dont les éléments sont de simple précision.

r = rand(1,4,"single")

r = 1×4 single row vector

    0.8147    0.9058    0.1270    0.9134

class(r)

ans = 
'single'

Taille définie par le tableau existant

Créez une matrice de nombres aléatoires uniformément distribués de la même taille qu’un tableau existant.

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

X = 2×2

    0.8147    0.1270
    0.9058    0.9134

Il est courant de combiner les deux lignes de code précédentes en une seule :

X = rand(size(A));

Taille et type de données définis par le tableau existant

Créez une matrice 2 x 2 avec des nombres aléatoires simple précision.

p = single([3 2; -2 1]);

Créez un tableau de nombres aléatoires de la même taille et du même type de données que p.

X = rand(size(p),like=p)

X = 2×2 single matrix

    0.8147    0.1270
    0.9058    0.9134

class(X)

ans = 
'single'

Nombres complexes aléatoires

Générez 10 nombres complexes aléatoires à partir de la distribution uniforme sur un domaine carré avec des parties réelles et imaginaires dans l’intervalle (0,1).

a = rand(10,1,like=1i)

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

Arguments d'entrée

n — Taille de la matrice carrée

valeur entière

Taille de la matrice carrée, spécifiée sous forme d’une valeur entière.

• Si n est égal à 0, alors X est une matrice vide.

• Si n est négatif, il est traité comme 0.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

sz1,...,szN — Taille de chaque dimension (sous forme d’arguments distincts)

valeurs entières

Taille de chaque dimension, spécifiée sous forme d’arguments distincts de valeurs entières.

• Si la taille d’une dimension est égale à 0, alors X est un tableau vide.

• Si la taille d’une dimension est négative, elle est traitée comme une taille égale à 0.

• Au-delà de la deuxième dimension, rand ignore les dimensions suivantes de taille 1. Par exemple, rand(3,1,1,1) produit un vecteur de nombres aléatoires de dimension 3 x 1.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

sz — Taille de chaque dimension (en tant que vecteur ligne)

valeurs entières

Taille de chaque dimension, spécifiée sous forme d’un vecteur ligne de valeurs entières. Chaque élément de ce vecteur indique la taille de la dimension correspondante :

• Si la taille d’une dimension est égale à 0, alors X est un tableau vide.

• Si la taille d’une dimension est négative, elle est traitée comme une taille égale à 0.

• Au-delà de la deuxième dimension, rand ignore les dimensions suivantes de taille 1. Par exemple, rand([3 1 1 1]) produit un vecteur de nombres aléatoires de dimension 3 x 1.

Exemple : sz = [2 3 4] crée un tableau de dimension 2 x 3 x 4.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

typename — Type de données (classe) à créer

"double" (par défaut) | "single"

Type de données (classe) à créer, spécifié comme "double", "single" ou le nom d’une autre classe supportant rand.

Exemple : rand(5,"single")

p — Prototype du tableau à créer

tableau numérique

Prototype du tableau à créer, spécifié sous forme de tableau numérique.

Exemple : rand(5,like=p)

Types de données : single | double
Support des nombres complexes : Oui

s — Série de nombres aléatoires

Objet RandStream

Série de nombres aléatoires, spécifiée sous forme d’un objet RandStream.

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

Arguments de sortie

X — Tableau en sortie

scalaire | vecteur | matrice | tableau multidimensionnel

Tableau en sortie, renvoyé sous forme de scalaire, de vecteur, de matrice ou de tableau multidimensionnel.

En savoir plus

Générateur de nombres pseudo-aléatoires

Le générateur de nombres sous-jacent de rand est un générateur de nombres pseudo-aléatoires qui crée une séquence déterministe de nombres semblant aléatoires. Ces nombres sont prévisibles si la valeur initiale et l’algorithme déterministe du générateur sont connus. Bien qu’ils ne soient pas véritablement aléatoires, les nombres générés réussissent divers tests statistiques de stochasticité en remplissant la condition de distribution indépendante et identique (i.i.d.), ce qui justifie leur qualificatif de pseudo-aléatoires.

Conseils

• La séquence de nombres produite par rand est déterminée par les paramètres internes du générateur de nombres pseudo-aléatoires uniforme qui sous-tend rand, randi et randn. Vous pouvez contrôler ce générateur de nombres aléatoires partagé à l’aide de rng.

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• S’il est utilisé, l’argument en entrée typename doit être "double", "single", "int8", "uint8", "int16", "uint16", "int32", "uint32" ou "logical". Les autres classes ne sont pas supportées même si elles définissent une méthode rand statique.

• S’ils sont utilisés, les arguments de taille n, sz et sz1,...,szN doivent être de taille fixe.

• Le générateur de code utilise des mathématiques double précision pour calculer des sorties simple précision.

• Dans la plupart des cas, les fichiers MEX générés utilisent le même état de nombre aléatoire que MATLAB^®. Si vous désactivez les appels extrinsèques ou si vous appelez rand à l’intérieur d’une boucle parfor, le code MEX généré et le code autonome conservent leur propre état de nombre aléatoire qui est initialisé à la valeur MATLAB par défaut, à savoir rng(0,"twister").

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction supporte entièrement les environnements basés sur des threads. Pour plus d’informations, consultez Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

La fonction rand supporte les GPU arrays avec les notes d’usage et limitations suivantes :

• Vous pouvez spécifier typename en tant que 'gpuArray'. Si vous spécifiez typename en tant que 'gpuArray', le type sous-jacent par défaut du tableau est double.

  Pour créer un GPU array dont le type sous-jacent est datatype, spécifiez le type sous-jacent en tant qu’argument supplémentaire avant typename. Par exemple, X = rand(3,datatype,'gpuArray') crée un GPU array de nombres aléatoires de dimension 3 x 3 dont le type sous-jacent est datatype.

  Vous pouvez spécifier le datatype de type sous-jacent selon les options suivantes :

  • 'double'

  • 'single'

• Vous pouvez également spécifier la variable numérique p en tant que gpuArray.

  Si vous spécifiez p en tant que gpuArray, le type sous-jacent du tableau renvoyé est le même que p.

• Pour qu’il soit possible d’utiliser la syntaxe de série rand(s,___) sur un GPU, s doit être un objet parallel.gpu.RandStream (Parallel Computing Toolbox).

Pour plus d’informations, consultez Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Distributed arrays

Divisez les tableaux volumineux dans la mémoire combinée de votre cluster avec Parallel Computing Toolbox™.

Notes d’usage et limitations :

• La syntaxe de série rand(s,___) n’est pas supportée pour les tableaux codistributed ou distributed.

• Vous pouvez spécifier typename en tant que 'codistributed' ou 'distributed'. Si vous spécifiez typename en tant que 'codistributed' ou 'distributed', le type sous-jacent par défaut du tableau retourné est double.

  Pour créer un tableau distribué (distributed array) ou codistribué (codistributed array) avec le type sous-jacent datatype, spécifiez le type sous-jacent en tant qu’argument supplémentaire avant typename. Par exemple, X = rand(3,datatype,'distributed') crée une matrice distribuée de nombres aléatoires de 3 x 3 avec le type sous-jacent datatype.

  Vous pouvez spécifier le datatype de type sous-jacent selon les options suivantes :

  • 'double'

  • 'single'

• Vous pouvez également spécifier p en tant que tableau codistributed ou distributed.

  Si vous spécifiez p en tant que tableau codistributed ou distributed, le type sous-jacent du tableau renvoyé est le même que p.

• Pour voir d’autres syntaxes codistributed, consultez rand (codistributed) (Parallel Computing Toolbox).

Pour plus d’informations, consultez Exécuter les fonctions MATLAB avec des tableaux distribués (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

R2022a: Faites correspondre la complexité avec like et utilisez like avec l’objet RandStream

L’argument nom-valeur like supporte les tableaux de prototypes réels et complexes. Par exemple :

r = rand(2,2,like=1i)

r =

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

Toutes les syntaxes supportent cette fonctionnalité. Vous pouvez également utiliser like avec un objet RandStream comme première entrée de rand.

R2014a: Faire correspondre le type de données d’une variable existante avec 'like'

Pour générer des nombres aléatoires avec le même type de données qu’une variable existante, utilisez la syntaxe rand(__,'like',p). Par exemple :

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

ans = 
single

Cette fonctionnalité n’est pas disponible lorsqu’un objet RandStream est transmis comme première entrée à rand.

R2013b: Les entrées de taille non entières ne sont pas supportées

La spécification d’une dimension qui n’est pas un entier provoque une erreur. Utilisez floor pour convertir les entrées de taille non entières en nombres entiers.

R2008b: Les entrées 'seed', 'state' et 'twister' ne sont pas recommandées

Il n’est pas prévu de supprimer ces entrées, qui contrôlent le générateur de nombres aléatoires qui sous-tend rand, randi et randn. Cependant, nous recommandons plutôt la fonction rng pour les motifs suivants :

• Les générateurs 'seed' et 'state' sont défectueux.

• Les termes 'seed' et 'state' sont des noms trompeurs pour les générateurs. 'seed' fait référence au générateur MATLAB v4, et non à la valeur d’initialisation de la graine. 'state' fait référence aux générateurs v5, et non à l’état interne du générateur.

• Ces trois entrées utilisent inutilement des générateurs différents pour rand et randn.

Pour plus d’informations sur l’actualisation de votre code, consultez Replace Discouraged Syntaxes of rand and randn.

Voir aussi

randi | randn | rng | RandStream | sprand | sprandn | randperm

Rubriques

• Create Arrays of Random Numbers
• Controlling Random Number Generation
• Nombres aléatoires dans une plage spécifique
• Class Support for Array-Creation Functions
• Why Do Random Numbers Repeat After Startup?