Générer des nombres aléatoires de manière uniforme sur toute une plage de valeurs

Question

Je dois générer des nombres aléatoires dans un intervalle spécifié, [max;min].

De plus, les nombres aléatoires doivent être répartis uniformément sur l'intervalle, et non localisés à un point particulier.

Actuellement, je génère en tant que :

for(int i=0; i<6; i++)
{
    DWORD random = rand()%(max-min+1) + min;
}

D'après mes tests, les numéros aléatoires sont générés autour d'un seul point.

Example
min = 3604607;
max = 7654607;

Numéros aléatoires générés :

3631594
3609293
3630000
3628441
3636376
3621404

A partir des réponses ci-dessous : OK, RAND_MAX est 32767. Je suis sur une plateforme C++ Windows. Existe-t-il une autre méthode pour générer des nombres aléatoires avec une distribution uniforme ?

Answer 1

Pourquoi rand est une mauvaise idée

La plupart des réponses que vous avez obtenues ici utilisent l'expression rand et l'opérateur de module. Cette méthode peut ne pas générer les nombres de manière uniforme (cela dépend de la plage et de la valeur de l'option RAND_MAX ), et est donc déconseillé.

C++11 et génération sur une gamme

Avec C++11, de multiples autres options sont apparues. L'une d'entre elles répond très bien à votre besoin de générer un nombre aléatoire dans un intervalle : std::uniform_int_distribution . Voici un exemple :

const int range_from  = 0;
const int range_to    = 10;
std::random_device                  rand_dev;
std::mt19937                        generator(rand_dev());
std::uniform_int_distribution<int>  distr(range_from, range_to);

std::cout << distr(generator) << '\n';

Et aquí C'est l'exemple à suivre.

La fonction de modèle peut aider certains :

template<typename T>
T random(T range_from, T range_to) {
    std::random_device                  rand_dev;
    std::mt19937                        generator(rand_dev());
    std::uniform_int_distribution<T>    distr(range_from, range_to);
    return distr(generator);
}

Autres générateurs aléatoires

El <random> en-tête propose d'innombrables autres générateurs de nombres aléatoires avec différents types de distributions, notamment Bernoulli, Poisson et normale.

Comment puis-je mélanger un conteneur ?

La norme prévoit std::shuffle qui peut être utilisé comme suit :

std::vector<int> vec = {4, 8, 15, 16, 23, 42};

std::random_device random_dev;
std::mt19937       generator(random_dev());

std::shuffle(vec.begin(), vec.end(), generator);

L'algorithme réordonnera les éléments de manière aléatoire, avec une complexité linéaire.

Boost.Random

Une autre alternative, dans le cas où vous n'avez pas accès à un compilateur C++11+, est d'utiliser Boost.Random . Son interface est très similaire à celle du C++11.

Answer 2

[modifier] Avertissement : Ne pas utiliser rand() pour les statistiques, la simulation, la cryptographie ou tout autre sujet sérieux.

C'est assez bon pour faire des chiffres regardez aléatoire pour un humain typique et pressé, pas plus.

Voir La réponse de @Jefffrey pour de meilleures options, ou cette réponse pour des nombres aléatoires crypto-sécurisés.

---

En général, les bits de poids fort présentent une meilleure distribution que les bits de poids faible, de sorte que la méthode recommandée pour générer des nombres aléatoires d'une plage à des fins simples est la suivante :

((double) rand() / (RAND_MAX+1)) * (max-min+1) + min

Note : s'assurer que RAND_MAX+1 ne déborde pas (merci Demi) !

La division génère un nombre aléatoire dans l'intervalle [0, 1] ; "étirez" celui-ci jusqu'à la plage requise. Ce n'est que lorsque max-min+1 se rapproche de RAND_MAX que vous avez besoin d'une fonction "BigRand()" comme celle proposée par Mark Ransom.

Cela permet également d'éviter certains problèmes de découpage dus au modulo, qui peuvent détériorer encore plus vos chiffres.

---

Le générateur de nombres aléatoires intégré n'est pas garanti d'avoir la qualité requise pour les simulations statistiques. Il est acceptable que les nombres "semblent aléatoires" pour un humain, mais pour une application sérieuse, vous devriez prendre quelque chose de mieux - ou au moins vérifier ses propriétés (une distribution uniforme est généralement bonne, mais les valeurs ont tendance à se corréler, et la séquence est déterministe). Knuth a rédigé un excellent traité (bien que difficile à lire) sur les générateurs de nombres aléatoires, et j'ai récemment découvert que LFSR est excellent et très simple à mettre en œuvre, si ses propriétés vous conviennent.

Answer 3

Si RAND_MAX est de 32767, vous pouvez facilement doubler le nombre de bits.

int BigRand()
{
    assert(INT_MAX/(RAND_MAX+1) > RAND_MAX);
    return rand() * (RAND_MAX+1) + rand();
}

Answer 4

Si vous le pouvez, utilisez Boost . J'ai eu de la chance avec leur bibliothèque aléatoire .

uniform_int devrait faire ce que vous voulez.

Answer 5

Si vous êtes préoccupé par le caractère aléatoire et non par la vitesse, vous devez utiliser une méthode de génération de nombres aléatoires sécurisée. Il existe plusieurs façons de le faire... La plus simple étant d'utiliser La méthode d'OpenSSL Générateur de nombres aléatoires .

Vous pouvez également écrire le vôtre à l'aide d'un algorithme de cryptage (tel que AES ). En choisissant une graine et un IV puis en rechiffrant continuellement la sortie de la fonction de chiffrement. Utiliser OpenSSL est plus facile, mais moins viril.