Comment les nombres aléatoires sont générés

Comprendre la génération de nombres aléatoires

Les nombres aléatoires jouent un rôle crucial dans divers domaines tels que les simulations, la cryptographie, l'échantillonnage statistique, etc. Cet article explique comment les nombres aléatoires sont générés, en se concentrant sur deux langages de programmation populaires : JavaScript et Python.

Générateurs de nombres pseudo-aléatoires (PRNG)

La plupart des langages de programmation utilisent des générateurs de nombres pseudo-aléatoires (PRNG) pour produire des nombres aléatoires. Les PRNG utilisent des algorithmes mathématiques pour générer des séquences de nombres qui semblent aléatoires. Ces nombres ne sont pas vraiment aléatoires car ils sont déterminés par une valeur initiale appelée graine. Cependant, ils suffisent pour de nombreuses applications.

Caractéristiques des PRNG

1. Déterministe : Étant donné la même graine, un PRNG produira toujours la même séquence de nombres.
2. Périodicité : les PRNG finiront par répéter leur séquence de nombres après une certaine période.
3. Vitesse : les PRNG sont généralement rapides et efficaces.

JavaScript : Math.random()

La fonction Math.random() de JavaScript est couramment utilisée pour générer des nombres aléatoires. L'algorithme exact utilisé par Math.random() peut varier selon les différents moteurs JavaScript, mais un algorithme largement utilisé est le Mersenne Twister.

Comment fonctionne Math.random()

Le Mersenne Twister est connu pour sa longue période et son caractère aléatoire de haute qualité. Voici un exemple simplifié de la façon dont l'algorithme Mersenne Twister peut être implémenté en JavaScript :

class MersenneTwister {
  constructor(seed) {
    if (seed === undefined) {
      seed = new Date().getTime();
    }
    this.mt = new Array(624);
    this.index = 0;
    this.mt[0] = seed;
    for (let i = 1; i < 624; i++) {
      this.mt[i] = (0x6c078965 * (this.mt[i - 1] ^ (this.mt[i - 1] >> 30)) + i) >>> 0;
    }
  }

  generate() {
    if (this.index === 0) {
      this.twist();
    }
    let y = this.mt[this.index];
    y = y ^ (y >> 11);
    y = y ^ ((y << 7) & 0x9d2c5680);
    y = y ^ ((y << 15) & 0xefc60000);
    y = y ^ (y >> 18);
    this.index = (this.index + 1) % 624;
    return y / 0xffffffff;
  }

  twist() {
    for (let i = 0; i < 624; i++) {
      const y = (this.mt[i] & 0x80000000) + (this.mt[(i + 1) % 624] & 0x7fffffff);
      this.mt[i] = this.mt[(i + 397) % 624] ^ (y >> 1);
      if (y % 2 !== 0) {
        this.mt[i] = this.mt[i] ^ 0x9908b0df;
      }
    }
  }
}

// Example usage:
const mt = new MersenneTwister(12345); // Seed value
const randomNumber = mt.generate(); // Get a random number
console.log(randomNumber);

Ce code présente une version simplifiée de l'algorithme Mersenne Twister utilisé pour générer des nombres aléatoires.

Utiliser Math.random()

En JavaScript, vous pouvez générer un nombre aléatoire entre 0 (inclus) et 1 (exclusif) en utilisant Math.random() :

const randomNumber = Math.random();
console.log(randomNumber);

Python : module aléatoire

Python fournit le module random, qui comprend diverses fonctions pour générer des nombres aléatoires. L'algorithme PRNG par défaut utilisé par le module aléatoire de Python est également le Mersenne Twister.

Comment utiliser le module aléatoire de Python

Voici quelques exemples de génération de nombres aléatoires en Python :

import random

# Generate a random float between 0.0 and 1.0
random_float = random.random()
print(random_float)

# Generate a random integer between 1 and 100
random_int = random.randint(1, 100)
print(random_int)

# Generate a random number from a normal distribution with mean 0 and standard deviation 1
random_normal = random.gauss(0, 1)
print(random_normal)

Amorçage du générateur de nombres aléatoires

Pour garantir la reproductibilité, vous pouvez amorcer le générateur de nombres aléatoires en Python :

import random

# Seed the random number generator
random.seed(12345)

# Generate random numbers
print(random.random())
print(random.randint(1, 100))

L'utilisation de la même valeur de départ produira la même séquence de nombres aléatoires à chaque fois que vous exécuterez le programme.

Conclusion

La génération de nombres aléatoires est un concept fondamental avec un large éventail d'applications. Bien que les nombres générés par Math.random() en JavaScript et le module random en Python ne soient pas vraiment aléatoires, ils le sont suffisamment pour la plupart des objectifs pratiques. Comprendre comment fonctionnent ces générateurs et comment les utiliser efficacement est crucial pour les développeurs et les chercheurs.

---

Cet article fournit un aperçu de base de la façon dont les nombres aléatoires sont générés en JavaScript et Python, ainsi que des exemples pratiques d'utilisation de Math.random() et du module aléatoire de Python.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!