randn

Nombres aléatoires normalement distribués

Syntaxe

X = randn

X = randn(n)

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

X = randn(sz)

X = randn(___,typename)

X = randn(___,like=p)

X = randn(s,___)

Description

X = randn renvoie un scalaire aléatoire tiré de la distribution normale standard.

X = randn(n) renvoie une matrice de nombres aléatoires normalement distribués de dimension n x n.

X = randn(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, randn(3,4) renvoie une matrice 3 x 4.

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

X = randn(___,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 = randn(___,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 = randn(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 normalement distribués.

r = randn(5)

r = 5×5

    0.5377   -1.3077   -1.3499   -0.2050    0.6715
    1.8339   -0.4336    3.0349   -0.1241   -1.2075
   -2.2588    0.3426    0.7254    1.4897    0.7172
    0.8622    3.5784   -0.0631    1.4090    1.6302
    0.3188    2.7694    0.7147    1.4172    0.4889

Nombres aléatoires normaux bivariés

Générez des valeurs à partir d’une distribution normale bivariée avec un vecteur de moyennes et une matrice de covariance spécifiés.

mu = [1 2];
sigma = [1 0.5; 0.5 2];
R = chol(sigma);
z = repmat(mu,10,1) + randn(10,2)*R

z = 10×2

    1.5377    0.4831
    2.8339    6.9318
   -1.2588    1.8302
    1.8622    2.3477
    1.3188    3.1049
   -0.3077    1.0750
    0.5664    1.6190
    1.3426    4.1420
    4.5784    5.6532
    3.7694    5.2595

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 = randn(1,5)

r = 1×5

    0.5377    1.8339   -2.2588    0.8622    0.3188

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 = randn(1,5)

r1 = 1×5

    0.5377    1.8339   -2.2588    0.8622    0.3188

Tableau 3D de nombres aléatoires

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

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

X = 
X(:,:,1) =

    0.5377    0.8622
    1.8339    0.3188
   -2.2588   -1.3077


X(:,:,2) =

   -0.4336    2.7694
    0.3426   -1.3499
    3.5784    3.0349


X(:,:,3) =

    0.7254   -0.2050
   -0.0631   -0.1241
    0.7147    1.4897

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 = randn(1,4,"single")

r = 1×4 single row vector

    0.5377    1.8339   -2.2588    0.8622

class(r)

ans = 
'single'

Taille définie par le tableau existant

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

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

X = 2×2

    0.5377   -2.2588
    1.8339    0.8622

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

X = randn(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 = randn(size(p),like=p)

X = 2×2 single matrix

    0.5377   -2.2588
    1.8339    0.8622

class(X)

ans = 
'single'

Nombres complexes aléatoires

Depuis R2022a

Générez 10 nombres complexes aléatoires à partir de la distribution normale complexe standard.

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

a = 10×1 complex

   0.3802 + 1.2968i
  -1.5972 + 0.6096i
   0.2254 - 0.9247i
  -0.3066 + 0.2423i
   2.5303 + 1.9583i
  -0.9545 + 2.1460i
   0.5129 - 0.0446i
   0.5054 - 0.1449i
  -0.0878 + 1.0534i
   0.9963 + 1.0021i

Nombres complexes aléatoires avec une moyenne et une covariance spécifiées

Depuis R2022a

Par défaut, randn(__,like=1i) génère des nombres aléatoires à partir de la distribution normale complexe standard. Les parties réelles et imaginaires sont des variables aléatoires indépendantes normalement distribuées de moyenne 0 et de variance 1/2. La matrice de covariance d’une variable aléatoire 2D $z=\left[\text{Re}\left(z\right),\text{Im}\left(z\right)\right]$ est [1/2 0; 0 1/2]. Pour illustrer ce comportement par défaut, générez 50 000 nombres aléatoires avec randn et calculez leur covariance.

n = 50000;
z = randn(n,1,like=1i);
cov_z = cov(real(z),imag(z),1)

cov_z = 2×2

    0.4980    0.0007
    0.0007    0.4957

Pour générer des nombres aléatoires à partir d’une distribution normale complexe plus générale avec une moyenne et une covariance spécifiques, transformez les données générées à partir de la distribution par défaut. Pour une variable aléatoire à N dimensions $z=\left[z_1,z_2,\dots ,z_N\right]$ qui suit une distribution normale ayant une moyenne nulle et une matrice de covariance unitaire, vous pouvez transformer $z$ en $y=\mu +\text{zR}$. La variable $y$ suit la distribution normale avec la moyenne $\mu$ et la matrice de covariance $\sigma =R^{T}R$ qui est symétrique définie positive. Par exemple, spécifiez la moyenne $\mu =1+2i$ et la matrice de covariance $\sigma =\left[\begin{array}{cc}{\sigma }_{\text{xx}}& {\sigma }_{\text{xy}}\\ {\sigma }_{\text{yx}}& {\sigma }_{\text{yy}}\end{array}\right]=\left[\begin{array}{cc}2& -2\\ -2& 4\end{array}\right]$.

mu = 1 + 2i;
sigma = [2 -2; -2 4];

Calculez la décomposition de Cholesky de la matrice de covariance. Le résultat est une matrice triangulaire supérieure R telle que sigma = R'*R. Mettez les données d’origine à l’échelle en appliquant également un facteur de sqrt(2), car la variance des parties réelles et imaginaires de la distribution d’origine est 1/2. Décalez ensuite les données mises à l’échelle vers la moyenne spécifiée.

R = chol(sigma);
z_scaled = sqrt(2)*[real(z) imag(z)]*R*[1; 1i];
y = mu + z_scaled;

Affichez les 10 premiers nombres complexes générés.

y(1:10)

ans = 10×1 complex

   1.7604 + 3.8331i
  -2.1945 + 6.4138i
   1.4508 - 0.3002i
   0.3868 + 3.0977i
   6.0606 + 0.8560i
  -0.9090 + 8.2011i
   2.0259 + 0.8850i
   2.0108 + 0.6993i
   0.8244 + 4.2823i
   2.9927 + 2.0115i

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, randn ignore les dimensions suivantes de taille 1. Par exemple, randn(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, randn ignore les dimensions suivantes de taille 1. Par exemple, randn([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 randn.

Exemple : randn(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 : randn(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"); randn(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

Distributions normales réelles et complexes standard

Lors de la génération de nombres réels aléatoires, la fonction randn génère des données qui suivent la distribution normale standard :

$$f(x)=\frac{1}{\sqrt{2\pi }}{e}^{-x^2/2}.$$

Ici, x est une variable réelle aléatoire de moyenne 0 et de variance 1.

Lors de la génération de nombres complexes aléatoires, par exemple avec la commande randn(...,like=1i), la fonction randn génère des données qui suivent la distribution normale complexe standard :

$$f(z)=\frac{1}{\pi }{e}^{-{\left|z\right|}^2}.$$

Ici, z est une variable complexe aléatoire dont les parties réelle et imaginaire sont des variables aléatoires indépendantes normalement distribuées de moyenne 0 et de variance 1/2.

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

Le générateur de nombres sous-jacent de randn 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 randn 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 randn 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 randn à 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").

Génération de code GPU

Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Consultez les notes d’usage et limitations à la section « Génération de code C/C++ ». Les mêmes notes d’usage et limitations s’appliquent à la génération de code GPU.

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.

La fonction randn 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 randn 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 = randn(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 randn(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™.

La fonction randn supporte les distributed arrays avec les notes d’usage et limitations suivantes :

• La syntaxe de série randn(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 = randn(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 randn (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 = randn(2,2,like=1i)

r =

   0.3802 + 1.2968i   0.2254 - 0.9247i
  -1.5972 + 0.6096i  -0.3066 + 0.2423i

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

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 randn(__,'like',p). Par exemple :

A = single(pi);
r = randn(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 à randn.

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 | rand | rng | RandStream | sprand | sprandn | randperm

Rubriques

• Créer des tableaux de nombres aléatoires
• Controlling Random Number Generation
• Nombres aléatoires dans une plage spécifique
• Nombres aléatoires issus d’une distribution normale avec une moyenne et une variance spécifiques
• Random Numbers and Vectors from Multivariate Normal Distributions
• Class Support for Array-Creation Functions
• Why Do Random Numbers Repeat After Startup?