Comment Ruby génère des nombres aléatoires

La façon dont Ruby génère des nombres aléatoires : appelez d'abord srand n'importe où au début du programme ; puis lorsque vous l'exécutez, vous pouvez générer une série de nombres différents apparemment aléatoires.

L'environnement d'exploitation de cet article : système Windows 7, ordinateur Dell G3, Ruby version 3.0.0.

Générer des nombres aléatoires dans Ruby

Il peut être utilisé dans des programmes de plage (généralement des jeux et des simulations) pour générer des nombres aléatoires. Bien qu'aucun ordinateur ne puisse générer des nombres véritablement aléatoires, Ruby donne accès à des méthodes qui renvoient des nombres pseudo-aléatoires.

Les nombres ne sont pas réellement aléatoires

Aucun ordinateur ne peut générer des nombres véritablement aléatoires uniquement par le calcul. Le mieux qu’ils puissent faire est de générer des nombres pseudo-aléatoires, qui sont un ensemble de nombres qui semblent aléatoires mais qui ne le sont pas.

Pour un observateur humain, ces chiffres semblent effectivement aléatoires. Il n’y a pas de courtes séquences répétitives et, du moins pour un observateur humain, elles sont complètement aléatoires. Cependant, avec suffisamment de temps et de motivation, il est possible de découvrir la graine originale, de recréer la séquence et de deviner le numéro suivant de la séquence.

Par conséquent, les méthodes décrites dans cet article ne devraient probablement pas être utilisées pour générer des nombres qui doivent être cryptographiquement sécurisés.

Comme mentionné ci-dessus, les générateurs de nombres pseudo-aléatoires (PRNG) doivent être ensemencés afin qu'ils produisent une séquence différente à chaque fois qu'un nouveau nombre aléatoire est généré. Gardez à l’esprit qu’aucune méthode n’est magique : ces nombres apparemment aléatoires sont générés à l’aide d’algorithmes et d’une arithmétique relativement simples. En ensemençant un PRNG, vous pouvez repartir d'un point différent à chaque fois. Si vous ne faites pas de seed, cela produira la même séquence de nombres à chaque fois.

Dans Ruby, la méthode #srand du noyau peut être appelée sans paramètres. Il sélectionnera une graine de nombre aléatoire en fonction du temps, de l'ID de processus et du numéro de séquence. Appelez simplement srand n'importe où au début de votre programme et il générera une série différente de nombres apparemment aléatoires à chaque fois que vous l'exécuterez. Cette méthode est appelée implicitement lorsque le programme démarre et amorce le PRNG avec l'heure et l'ID de processus (pas de numéro de séquence).

Générer des nombres

Une fois le programme exécuté et le noyau #srand appelé implicitement ou explicitement, la méthode #rand du noyau peut être appelée. Cette méthode est appelée sans paramètres et renverra un nombre aléatoire de 0 à 1. Dans le passé, ce nombre était généralement mis à l'échelle au plus grand nombre que vous souhaitiez générer, peut-être avec un appel to_i pour le convertir en nombre entier.

# Generate an integer from 0 to 10
puts (rand() * 10).to_i

Cependant, si vous utilisez Ruby 1.9.x, Ruby rend les choses plus faciles. La méthode Kernel#rand peut accepter un seul paramètre. Si cet argument est un nombre de n'importe quel type, Ruby générera un entier de 0 à (exclusivement) ce nombre.

# Generate a number from 0 to 10
# In a more readable way
puts rand(10)

Mais que se passe-t-il si vous souhaitez générer un nombre de 10 à 15 ? Généralement, vous générerez un nombre de 0 à 5 et l'ajouterez à 10. Cependant, Ruby facilite les choses.

Vous pouvez transmettre un objet Range à Kernel#rand et il fait exactement ce à quoi vous vous attendez : génère un entier aléatoire dans la plage.

Assurez-vous de faire attention à la portée de ces deux types. Si vous appelez rand(10..15), un nombre de 10 à 15 inclus sera généré. Et rand(10...15) (avec 3 points) produira un nombre de 10 à 15, à l'exclusion de 15.

# Generate a number from 10 to 15
# Including 15
puts rand(10..15)

Nombres aléatoires non aléatoires

Parfois, vous avez besoin d'une séquence de nombres qui semble aléatoire, mais vous devez générer la même séquence à chaque fois. Par exemple, si vous générez des nombres aléatoires dans un test unitaire, vous devez générer la même séquence de nombres à chaque fois.

Un test unitaire qui échoue sur une séquence devrait échouer à nouveau la prochaine fois qu'il sera exécuté, ou s'il génère une séquence différente la prochaine fois, il risque de ne pas échouer. Pour ce faire, appelez le noyau #srand avec une valeur constante connue.

# Generate the same sequence of numbers every time
# the program is run
srand(5)
# Generate 10 random numbers
puts (0..10).map{rand(0..10)}

Notez que l'implémentation du noyau #rand n'est pas Ruby. Il n’abstrait en aucun cas PRNG et ne permet pas non plus l’instanciation de PRNG. Pour PRNG, tout le code partage un état global. Si vous changez la graine ou modifiez l'état du PRNG, les effets peuvent être plus larges que prévu.

Cependant, puisque le programme s'attend à ce que les résultats de cette méthode soient aléatoires (comme tel est son objectif), cela ne posera peut-être jamais de problème. Ce n'est que si le programme s'attend à voir une séquence de nombres attendue, par exemple s'il appelle srand avec une valeur constante, qu'il verra un résultat inattendu.

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!