Nombres aléatoires en R : rnorm, runif, sample et set.seed

set.seed() en premier

Des tirages aléatoires qui changent à chaque exécution sont inutiles pour l'enseignement, la correction, le débogage ou la science - si ta simulation dit 0,146 aujourd'hui et 0,153 demain, quel nombre va dans le rapport ? set.seed() fixe le point de départ du générateur, rendant tout le flux de « hasard » qui suit exactement reproductible :

set.seed(42)
print(rnorm(3))

set.seed(42)          # same seed...
print(rnorm(3))       # ...same "random" numbers

set.seed(7)           # different seed, different stream
print(rnorm(3))

Même graine, tirages identiques, à chaque fois, sur chaque machine. Les nombres sont pseudo-aléatoires : une suite déterministe conçue pour passer tous les tests statistiques d'aléatoire, la graine choisissant où tu démarres dans la suite. La valeur de la graine elle-même n'a aucun sens - 42, 7, 20260807 - prends ce que tu veux ; note-le simplement. L'habitude à prendre : un set.seed() en tête de tout script utilisant du hasard. (Note que consommer des tirages fait avancer l'état, donc l'ordre des appels compte aussi pour la reproductibilité.)

Le système d/p/q/r : un tableau décode toute la bibliothèque

R nomme chaque fonction de distribution comme préfixe + famille, et une fois la grille comprise, tu peux lire toute la bibliothèque statistique :

Préfixe	Question à laquelle il répond	Exemple normal
r	Donne-moi des tirages aléatoires	rnorm(5)
d	Densité : quelle est la hauteur de la courbe en x ?	dnorm(0)
p	Probabilité : P(X ≤ x) ?	pnorm(1.96)
q	Quantile : quel x se situe à ce percentile ?	qnorm(0.975)

p et q sont inverses l'un de l'autre, et c'est la paire que tu as croisée dans les intervalles de confiance sous la forme qt(0.975, df) :

print(pnorm(1.96))      # P(Z <= 1.96), about 0.975
print(qnorm(0.975))     # which z has 97.5% below it? About 1.96
print(dnorm(0))         # height of the bell curve at its peak

Change le nom de la famille et tout se transpose : runif/dunif/punif/qunif, rbinom/..., rpois/..., rt/..., rexp/.... Apprends quatre préfixes, obtiens des dizaines de distributions.

rnorm() : tirages normaux

rnorm(n, mean, sd) tire dans une courbe en cloche - le cheval de bataille pour simuler des données de type mesure :

set.seed(42)
iq <- rnorm(1000, mean = 100, sd = 15)

print(mean(iq))
print(sd(iq))
print(mean(iq > 130))   # share more than 2 sd above the mean

La moyenne et l'écart-type d'échantillon tombent près de - pas exactement sur - 100 et 15 : cet écart est le bruit d'échantillonnage, qui rétrécit quand n grandit. La dernière ligne est une astuce à voler : mean() d'un vecteur logique est la proportion de TRUE, et la part au-delà de 130 sort près du 1 - pnorm(130, 100, 15) théorique ≈ 2,3 %. Les valeurs par défaut sont mean = 0, sd = 1 (la normale centrée réduite). Un histogramme de iq montre la cloche familière.

runif(), rbinom(), rpois()

Trois autres familles couvrent l'essentiel des besoins de simulation :

set.seed(42)

print(runif(5))                    # uniform on [0, 1]
print(runif(3, min = 10, max = 20))

print(rbinom(8, size = 10, prob = 0.5))   # successes in 10 coin flips, 8 times

print(rpois(8, lambda = 3))        # event counts averaging 3 per interval

runif() répartit les tirages uniformément sur une plage (« uniform », pas « run if » - tout le monde le lit mal une fois). rbinom(n, size, prob) simule n expériences de size essais chacune, en renvoyant le nombre de succès de chacune - donc chaque valeur ci-dessus est un nombre de faces sur 10 lancers. rpois(n, lambda) génère des comptages d'événements survenant indépendamment à un taux moyen connu : tickets de support par heure, coquilles par page.

sample() : échantillonner et mélanger

Là où les fonctions r* inventent des valeurs à partir d'une distribution, sample() tire parmi des valeurs que tu as déjà :

set.seed(42)

print(sample(1:10, 3))                              # 3 values, no repeats
print(sample(c("win", "lose"), 5, replace = TRUE))  # 5 draws, repeats allowed
print(sample(1:5))                                  # no size = shuffle everything

L'argument replace résume tout : FALSE (par défaut) distribue des cartes - chaque valeur ne peut apparaître qu'une fois, et en demander plus que tu n'en as est une erreur ; TRUE lance des dés - chaque tirage remet tout à zéro. Échantillonner avec remise dans tes propres données est le moteur du bootstrap. Appelé avec un simple vecteur, sample(x) renvoie une permutation aléatoire - l'idiome pour mélanger.

Échantillonner des lignes d'un data frame utilise sample() dans l'indexation des lignes :

set.seed(42)

random_cars <- mtcars[sample(nrow(mtcars), 5), ]
print(random_cars[, c("mpg", "wt", "hp")])

sample(nrow(mtcars), 5) choisit 5 numéros de lignes au hasard ; l'indexation extrait ces lignes. C'est le geste standard pour contrôler par sondage un gros jeu de données ou pour découper des ensembles d'apprentissage et de test.

Une mini simulation de Monte-Carlo

Voici ce que rapporte toute la trousse. Question : un processus produit des mesures distribuées selon N(100, 15) ; tu en moyennes 10 - quelle est la probabilité que cette moyenne dépasse 105 ? Au lieu de dériver la réponse, simule-la - fais l'expérience 10 000 fois et compte :

set.seed(42)

trial <- function() {
  mean(rnorm(10, mean = 100, sd = 15)) > 105
}

results <- replicate(10000, trial())
print(mean(results))

# The exact answer, for comparison:
print(1 - pnorm(105, mean = 100, sd = 15 / sqrt(10)))

La simulation tombe à quelques millièmes de la valeur exacte (environ 0,146). Voilà Monte-Carlo en une phrase : écris un essai unique sous forme de fonction, replicate()-le des milliers de fois, prends la mean() des succès. La réponse exacte existait ici parce que la mise en scène était d'école - dès que la question se complique (distributions bizarres, maximum de tirages corrélés, un jeu régi par des règles), la voie analytique se ferme et la recette de simulation continue de fonctionner sans changement. Remarque le 15 / sqrt(10) dans la vérification : les moyennes fluctuent moins que les tirages individuels - la même loi de la racine carrée qui pilote la largeur des intervalles de confiance.

De qualité simulation, pas de qualité secret

Une limite à respecter : le générateur par défaut de R (Mersenne Twister) est conçu pour la qualité statistique et la vitesse, pas pour le secret. Sa sortie est déterministe étant donné la graine, et son état interne peut être reconstruit à partir des sorties observées - des défauts fatals pour des mots de passe, des jetons ou tout ce qui touche à la sécurité. Pour la simulation, le bootstrap et l'enseignement, il est excellent ; pour la cryptographie, utilise une bibliothèque dédiée (par exemple le package openssl), jamais sample() ni runif().

Ce que tu retiens

• Un set.seed() en tête rend chaque résultat « aléatoire » reproductible - même graine, mêmes tirages.
• Les préfixes d/p/q/r décodent toute la bibliothèque des distributions : tirage aléatoire, densité, probabilité cumulée, quantile.
• rnorm(n, mean, sd), runif(n, min, max), rbinom(n, size, prob), rpois(n, lambda) couvrent l'essentiel des besoins de simulation.
• sample() tire parmi tes propres valeurs - replace = TRUE pour les dés, la valeur par défaut pour les cartes, pas de size pour mélanger ; df[sample(nrow(df), k), ] échantillonne des lignes.
• Monte-Carlo = fonction d'un essai + replicate() + mean() - la recette qui répond aux questions de probabilité que les maths n'atteignent pas commodément.
• Le générateur de R est fait pour la simulation, pas pour la cryptographie.

Prochaine étape : le débogage - ce que signifient réellement les messages d'erreur de R et comment lire une pile d'appels.