randi

Nombres entiers aléatoires uniformément distribués

Syntaxe

X = randi(imax)

X = randi(imax,n)

X = randi(imax,sz1,...,szN)

X = randi(imax,sz)

X = randi(___,typename)

X = randi(___,like=p)

X = randi([imin,imax],___)

X = randi(s,___)

Description

X = randi(imax) renvoie un nombre entier scalaire aléatoire compris entre 1 et imax.

X = randi(imax,n) renvoie une matrice n x n de nombres entiers aléatoires tirés de la distribution uniforme discrète sur l’intervalle [1,imax].

X = randi(imax,sz1,...,szN) renvoie un tableau de dimension sz1 x … x szN, où sz1,...,szN indique la taille de chaque dimension. Par exemple, randi(10,3,4) renvoie un tableau 3 x 4 de nombres entiers aléatoires compris entre 1 et 10.

X = randi(imax,sz) renvoie un tableau où le vecteur de taille sz définit size(X). Par exemple, randi(10,[3 4]) renvoie un tableau 3 x 4 de nombres entiers aléatoires compris entre 1 et 10.

X = randi(___,typename) renvoie un tableau de nombres entiers aléatoires compris entre 1 et imax dont le type de données est typename. L’entrée typename peut être "single", "double", "int8", "uint8", "int16", "uint16", "int32", "uint32" ou "logical". Vous pouvez utiliser n’importe quel argument en entrée dans les syntaxes précédentes.

X = randi(___,like=p) renvoie un tableau de nombres entiers 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 = randi([imin,imax],___) renvoie un tableau contenant des nombres entiers tirés de la distribution uniforme discrète sur l’intervalle [imin,imax] avec l’une des syntaxes ci-dessus.

X = randi(s,___) génère des nombres entiers à 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 carrée de nombres entiers aléatoires

Générez une matrice 5 x 5 de nombres entiers aléatoires compris entre 1 et 10. La première entrée de randi indique le nombre entier le plus grand dans l’intervalle d’échantillonnage (le nombre entier le plus petit dans l’intervalle est 1).

r = randi(10,5)

r = 5×5

     9     1     2     2     7
    10     3    10     5     1
     2     6    10    10     9
    10    10     5     8    10
     7    10     9    10     7

Nombres entiers aléatoires dans un intervalle spécifié

Générez un vecteur colonne 10 x 1 de nombres entiers aléatoires uniformément distribués à partir de l’intervalle d’échantillonnage [-5,5].

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

r = 10×1

     3
     4
    -4
     5
     1
    -4
    -2
     1
     5
     5

Contrôler la génération de nombres aléatoires

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

s = rng;
r = randi(10,1,5)

r = 1×5

     9    10     2    10     7

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

rng(s);
r1 = randi(10,1,5)

r1 = 1×5

     9    10     2    10     7

Tableau 3D de nombres entiers aléatoires

Créez un tableau 3 x 2 x 3 de nombres entiers aléatoires uniformément distribués entre 1 et 500.

X = randi(500,[3,2,3])

X = 
X(:,:,1) =

   408   457
   453   317
    64    49


X(:,:,2) =

   140   483
   274    79
   479   486


X(:,:,3) =

   479    71
   243   211
   401   458

Nombres entiers aléatoires d’autres types de données

Créez un vecteur 1 x 4 de nombres aléatoires compris entre 1 et 100 dont les éléments sont de type int16.

r = randi(100,1,4,"int16")

r = 1×4 int16 row vector

   82   91   13   92

class(r)

ans = 
'int16'

Taille définie par le tableau existant

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

A = [3 2; -2 1];
sz = size(A);
X = randi(10,sz)

X = 2×2

     9     2
    10    10

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

X = randi(10,size(A));

Taille et type de données numérique définis par un tableau existant

Créez une matrice 2 x 2 de nombres entiers signés de 8 bits.

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

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

X = randi(10,size(p),like=p)

X = 2×2 int8 matrix

    9    2
   10   10

class(X)

ans = 
'int8'

Nombres entiers complexes aléatoires

Depuis R2022a

Générez 10 nombres entiers complexes aléatoires à partir de la distribution uniforme discrète sur un domaine carré avec des parties réelles et imaginaires dans l’intervalle [-5,5].

a = randi([-5,5],10,1,like=1i)

a = 10×1 complex

   3.0000 + 4.0000i
  -4.0000 + 5.0000i
   1.0000 - 4.0000i
  -2.0000 + 1.0000i
   5.0000 + 5.0000i
  -4.0000 + 5.0000i
   5.0000 + 0.0000i
   3.0000 - 4.0000i
  -1.0000 + 5.0000i
   3.0000 + 5.0000i

Tableau logique aléatoire

Depuis R2023a

Créez une matrice 5 x 5 de valeurs logiques (0 et 1) aléatoires avec une distribution uniforme discrète.

r = randi([0 1],5,"logical")

r = 5×5 logical array

   1   0   0   0   1
   1   0   1   0   0
   0   1   1   1   1
   1   1   0   1   1
   1   1   1   1   1

Arguments d'entrée

imax — Nombre entier le plus grand dans l’intervalle d’échantillonnage

nombre entier positif

Nombre entier le plus grand dans l’intervalle d’échantillonnage, spécifié sous forme d’un nombre entier positif. randi tire des valeurs de la distribution uniforme dans l’intervalle d’échantillonnage [1,imax].

Exemple : randi(10,5)

imin — Nombre entier le plus petit dans l’intervalle d’échantillonnage

1 (par défaut) | nombre entier scalaire

Nombre entier le plus petit dans l’intervalle d’échantillonnage, spécifié sous forme d’un nombre entier scalaire.

imin et imax doivent tous deux être des nombres entiers tels que imin ≤ imax.

Par exemple, randi([50,100],5) renvoie une matrice 5 x 5 de nombres entiers aléatoires compris entre 50 et 100 (inclus).

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, randi ignore les dimensions suivantes de taille 1. Par exemple, randi([5,10],3,1,1,1) produit un vecteur 3 x 1 de nombres entiers aléatoires compris entre 5 et 10.

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, randi ignore les dimensions suivantes de taille 1. Par exemple, randi([5,10],[3 1 1 1]) produit un vecteur 3 x 1 de nombres entiers aléatoires compris entre 5 et 10.

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" | "int8" | "uint8" | "int16" | "uint16" | ...

Type de données (classe) à créer, spécifié comme "double", "single", "int8", "uint8", "int16", "uint16", "int32", "uint32", "logical" ou le nom d’une autre classe supportant randi.

Exemple : randi(5,5,"int8")

p — Prototype du tableau à créer

tableau numérique | tableau logique

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

Exemple : randi(5,5,like=p)

Types de données : single | double | int8 | int16 | int32 | uint8 | uint16 | uint32 | logical
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"); randi(s,[5,10],[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 randi 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 randi 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.

• Les tableaux renvoyés par randi peuvent contenir des valeurs entières répétées. Ce comportement est parfois appelé échantillonnage avec remplacement. Si vous souhaitez que toutes les valeurs soient uniques, utilisez randperm.

• Si imin et imax sont en dehors de la plage du type de sortie (tel que spécifié par typename ou par le prototype p), randi crée d’abord des nombres entiers aléatoires dans l’intervalle [imin,imax] puis convertit les éventuels nombres entiers hors plage qui en résultent en la valeur minimale ou maximale du type de sortie. Par exemple :

  rng default;
  r = randi([-10 10],1,10)

  r =
  
       7     9    -8     9     3    -8    -5     1    10    10

  rng default;
  r = randi([-10 10],1,10,"logical")

  r =
  
    1×10 logical array
  
     1   1   0   1   1   0   0   1   1   1

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 randi 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 randi à 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 randi 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 = randi(imax,3,datatype,'gpuArray') crée un GPU array 3 x 3 de nombres entiers aléatoires dans la plage [1 imax] avec le type sous-jacent datatype.

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

  • 'double'

  • 'single'

  • 'logical'

  • 'int8'

  • 'uint8'

  • 'int16'

  • 'uint16'

  • 'int32'

  • 'uint32'

• 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 randi(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 randi(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 = randi(imax,3,datatype,'distributed') crée une matrice 3 x 3 distribuée de nombres entiers aléatoires dans la plage [1 imax] avec le type sous-jacent datatype.

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

  • 'double'

  • 'single'

  • 'int8'

  • 'uint8'

  • 'int16'

  • 'uint16'

  • 'int32'

  • 'uint32'

  • 'logical'

• 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 randi (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 dans R2008b

R2023a: Créer un tableau logique aléatoire

Vous pouvez créer un tableau logique aléatoire en spécifiant typename comme "logical" ou le prototype p en tant que tableau logique. Par exemple, consultez Tableau logique aléatoire.

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 = randi(2,2,like=1i)

r =

   2.0000 + 2.0000i   2.0000 + 1.0000i
   1.0000 + 2.0000i   1.0000 + 2.0000i

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

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

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

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.

Voir aussi

rand | randn | rng | RandStream | randperm

Rubriques

• Nombres entiers aléatoires
• Create Arrays of Random Numbers
• Generate Random Numbers That Are Repeatable
• Generate Random Numbers That Are Different
• Creating and Controlling a Random Number Stream
• Class Support for Array-Creation Functions
• Why Do Random Numbers Repeat After Startup?