Comment générer un nombre entier aléatoire à partir d'une plage

Ceci est la suite d'une question précédemment publiée:

Comment générer un nombre aléatoire en C?

Je souhaite pouvoir générer un nombre aléatoire à partir d'une plage particulière, telle que 1 à 6, pour imiter les côtés d'un dé.

Comment pourrais-je procéder?

Toutes les réponses à ce jour sont mathématiquement fausses. Le retour rand() % Nne donne pas uniformément un nombre dans la plage à [0, N)moins de Ndiviser la longueur de l'intervalle dans lequel rand()renvoie (c'est-à-dire une puissance de 2). De plus, on ne sait pas si les modules de rand()sont indépendants: il est possible qu'ils disparaissent 0, 1, 2, ..., ce qui est uniforme mais pas très aléatoire. La seule hypothèse qu'il semble raisonnable de faire est celle qui rand()émet une distribution de Poisson: deux sous-intervalles non chevauchants de même taille sont également probables et indépendants. Pour un ensemble fini de valeurs, cela implique une distribution uniforme et garantit également que les valeurs de rand()sont bien dispersées.

Cela signifie que la seule façon correcte de modifier la plage de rand()est de la diviser en cases; par exemple, si RAND_MAX == 11et vous voulez une plage de 1..6, vous devez attribuer {0,1}à 1, {2,3}à 2, et ainsi de suite. Ce sont des intervalles disjoints, de taille égale et donc distribués uniformément et indépendamment.

La suggestion d'utiliser la division en virgule flottante est mathématiquement plausible mais souffre en principe de problèmes d'arrondi. La doubleprécision est peut -être suffisamment élevée pour que cela fonctionne; peut-être pas. Je ne sais pas et je ne veux pas avoir à le comprendre; dans tous les cas, la réponse dépend du système.

La bonne façon est d'utiliser l'arithmétique des nombres entiers. Autrement dit, vous voulez quelque chose comme ce qui suit:

#include <stdlib.h> // For random(), RAND_MAX

// Assumes 0 <= max <= RAND_MAX
// Returns in the closed interval [0, max]
long random_at_most(long max) {
  unsigned long
    // max <= RAND_MAX < ULONG_MAX, so this is okay.
    num_bins = (unsigned long) max + 1,
    num_rand = (unsigned long) RAND_MAX + 1,
    bin_size = num_rand / num_bins,
    defect   = num_rand % num_bins;

  long x;
  do {
   x = random();
  }
  // This is carefully written not to overflow
  while (num_rand - defect <= (unsigned long)x);

  // Truncated division is intentional
  return x/bin_size;
}

La boucle est nécessaire pour obtenir une distribution parfaitement uniforme. Par exemple, si vous recevez des nombres aléatoires de 0 à 2 et que vous ne voulez que des nombres de 0 à 1, vous continuez à tirer jusqu'à ce que vous n'obteniez pas un 2; il n'est pas difficile de vérifier que cela donne 0 ou 1 avec une probabilité égale. Cette méthode est également décrite dans le lien que nos a donné dans leur réponse, bien que codée différemment. J'utilise random()plutôt que rand()car il a une meilleure distribution (comme indiqué par la page de manuel pour rand()).

Si vous souhaitez obtenir des valeurs aléatoires en dehors de la plage par défaut [0, RAND_MAX], vous devez faire quelque chose de délicat. Le plus opportun est peut-être de définir une fonction random_extended()qui extrait les nbits (en utilisant random_at_most()) et les retourne [0, 2**n), puis appliquez random_at_most()avec random_extended()à la place de random()(et 2**n - 1à la place de RAND_MAX) pour extraire une valeur aléatoire inférieure à 2**n, en supposant que vous avez un type numérique qui peut contenir un tel une valeur. Enfin, bien sûr, vous pouvez obtenir des valeurs en [min, max]utilisant min + random_at_most(max - min), y compris des valeurs négatives.

Suite à la réponse de @Ryan Reich, j'ai pensé proposer ma version nettoyée. La première vérification des limites n'est pas requise étant donné la deuxième vérification des limites, et je l'ai rendue itérative plutôt que récursive. Il renvoie des valeurs dans la plage [min, max], où max >= minet 1+max-min < RAND_MAX.

unsigned int rand_interval(unsigned int min, unsigned int max)
{
    int r;
    const unsigned int range = 1 + max - min;
    const unsigned int buckets = RAND_MAX / range;
    const unsigned int limit = buckets * range;

    /* Create equal size buckets all in a row, then fire randomly towards
     * the buckets until you land in one of them. All buckets are equally
     * likely. If you land off the end of the line of buckets, try again. */
    do
    {
        r = rand();
    } while (r >= limit);

    return min + (r / buckets);
}

Voici une formule si vous connaissez les valeurs max et min d'une plage et que vous souhaitez générer des nombres compris entre la plage:

r = (rand() % (max + 1 - min)) + min

unsigned int
randr(unsigned int min, unsigned int max)
{
       double scaled = (double)rand()/RAND_MAX;

       return (max - min +1)*scaled + min;
}

Voir ici pour d'autres options.

Ne feriez-vous pas simplement:

srand(time(NULL));
int r = ( rand() % 6 ) + 1;

%est l'opérateur de module. Essentiellement, il divise simplement par 6 et renvoie le reste ... de 0 à 5

Pour ceux qui comprennent le problème du biais mais ne supportent pas le temps d'exécution imprévisible des méthodes basées sur le rejet, cette série produit un entier aléatoire progressivement moins biaisé dans l' [0, n-1]intervalle:

r = n / 2;
r = (rand() * n + r) / (RAND_MAX + 1);
r = (rand() * n + r) / (RAND_MAX + 1);
r = (rand() * n + r) / (RAND_MAX + 1);
...

Pour ce faire, il synthétise un nombre aléatoire de i * log_2(RAND_MAX + 1)bits à virgule fixe de haute précision (où iest le nombre d'itérations) et effectue une longue multiplication par n.

Lorsque le nombre de bits est suffisamment grand par rapport à n, la polarisation devient incommensurablement petite.

Peu importe si RAND_MAX + 1est inférieur à n(comme dans cette question ), ou si ce n'est pas une puissance de deux, mais il faut veiller à éviter un débordement d'entier si RAND_MAX * nest grand.

Afin d'éviter le biais modulo (suggéré dans d'autres réponses), vous pouvez toujours utiliser:

arc4random_uniform(MAX-MIN)+MIN

Où "MAX" est la limite supérieure et "MIN" est la limite inférieure. Par exemple, pour les nombres entre 10 et 20:

arc4random_uniform(20-10)+10

arc4random_uniform(10)+10

Solution simple et meilleure que d'utiliser "rand ()% N".

Voici un algorithme légèrement plus simple que la solution de Ryan Reich:

/// Begin and end are *inclusive*; => [begin, end]
uint32_t getRandInterval(uint32_t begin, uint32_t end) {
    uint32_t range = (end - begin) + 1;
    uint32_t limit = ((uint64_t)RAND_MAX + 1) - (((uint64_t)RAND_MAX + 1) % range);

    /* Imagine range-sized buckets all in a row, then fire randomly towards
     * the buckets until you land in one of them. All buckets are equally
     * likely. If you land off the end of the line of buckets, try again. */
    uint32_t randVal = rand();
    while (randVal >= limit) randVal = rand();

    /// Return the position you hit in the bucket + begin as random number
    return (randVal % range) + begin;
}

Example (RAND_MAX := 16, begin := 2, end := 7)
    => range := 6  (1 + end - begin)
    => limit := 12 (RAND_MAX + 1) - ((RAND_MAX + 1) % range)

The limit is always a multiple of the range,
so we can split it into range-sized buckets:
    Possible-rand-output: 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16
    Buckets:             [0, 1, 2, 3, 4, 5][0, 1, 2, 3, 4, 5][X, X, X, X, X]
    Buckets + begin:     [2, 3, 4, 5, 6, 7][2, 3, 4, 5, 6, 7][X, X, X, X, X]

1st call to rand() => 13
    → 13 is not in the bucket-range anymore (>= limit), while-condition is true
        → retry...
2nd call to rand() => 7
    → 7 is in the bucket-range (< limit), while-condition is false
        → Get the corresponding bucket-value 1 (randVal % range) and add begin
    => 3

Bien que Ryan ait raison, la solution peut être beaucoup plus simple en fonction de ce que l'on sait de la source du caractère aléatoire. Pour reformuler le problème:

• Il existe une source de caractère aléatoire, produisant des nombres entiers dans une plage [0, MAX)avec une distribution uniforme.
• L'objectif est de produire des nombres entiers aléatoires uniformément répartis dans la plage [rmin, rmax]où 0 <= rmin < rmax < MAX.

D'après mon expérience, si le nombre de bacs (ou «boîtes») est significativement plus petit que la plage des nombres d'origine, et que la source d'origine est cryptographiquement forte - il n'est pas nécessaire de passer par tout ce rigamarole, et une simple division modulo le ferait suffisent (comme output = rnd.next() % (rmax+1), si rmin == 0), et produisent des nombres aléatoires qui sont distribués uniformément "assez", et sans aucune perte de vitesse. Le facteur clé est la source aléatoire (c.-à-d. Les enfants, n'essayez pas cela à la maison avec rand()).

Voici un exemple / preuve de son fonctionnement dans la pratique. Je voulais générer des nombres aléatoires de 1 à 22, ayant une source cryptographiquement forte produisant des octets aléatoires (basé sur Intel RDRAND). Les résultats sont:

Rnd distribution test (22 boxes, numbers of entries in each box):     
 1: 409443    4.55%
 2: 408736    4.54%
 3: 408557    4.54%
 4: 409125    4.55%
 5: 408812    4.54%
 6: 409418    4.55%
 7: 408365    4.54%
 8: 407992    4.53%
 9: 409262    4.55%
10: 408112    4.53%
11: 409995    4.56%
12: 409810    4.55%
13: 409638    4.55%
14: 408905    4.54%
15: 408484    4.54%
16: 408211    4.54%
17: 409773    4.55%
18: 409597    4.55%
19: 409727    4.55%
20: 409062    4.55%
21: 409634    4.55%
22: 409342    4.55%   
total: 100.00%

C'est aussi proche de l'uniformité que nécessaire pour mon objectif (lancer de dés équitables, générer des livres de codes cryptographiquement forts pour les machines de chiffrement de la Seconde Guerre mondiale telles que http://users.telenet.be/d.rijmenants/en/kl-7sim.htm , etc. ). La sortie ne montre aucun biais appréciable.

Voici la source du générateur de nombres aléatoires (vrais) forts cryptographiquement: Intel Digital Random Number Generator et un exemple de code qui produit des nombres aléatoires 64 bits (non signés).

int rdrand64_step(unsigned long long int *therand)
{
  unsigned long long int foo;
  int cf_error_status;

  asm("rdrand %%rax; \
        mov $1,%%edx; \
        cmovae %%rax,%%rdx; \
        mov %%edx,%1; \
        mov %%rax, %0;":"=r"(foo),"=r"(cf_error_status)::"%rax","%rdx");
        *therand = foo;
  return cf_error_status;
}

Je l'ai compilé sur Mac OS X avec clang-6.0.1 (directement), et avec gcc-4.8.3 en utilisant le drapeau "-Wa, q" (car GAS ne prend pas en charge ces nouvelles instructions).

Comme dit précédemment, modulo n'est pas suffisant car il fausse la distribution. Voici mon code qui masque les bits et les utilise pour s'assurer que la distribution n'est pas biaisée.

static uint32_t randomInRange(uint32_t a,uint32_t b) {
    uint32_t v;
    uint32_t range;
    uint32_t upper;
    uint32_t lower;
    uint32_t mask;

    if(a == b) {
        return a;
    }

    if(a > b) {
        upper = a;
        lower = b;
    } else {
        upper = b;
        lower = a; 
    }

    range = upper - lower;

    mask = 0;
    //XXX calculate range with log and mask? nah, too lazy :).
    while(1) {
        if(mask >= range) {
            break;
        }
        mask = (mask << 1) | 1;
    }


    while(1) {
        v = rand() & mask;
        if(v <= range) {
            return lower + v;
        }
    }

}

Le code simple suivant vous permet d'examiner la distribution:

int main() {

    unsigned long long int i;


    unsigned int n = 10;
    unsigned int numbers[n];


    for (i = 0; i < n; i++) {
        numbers[i] = 0;
    }

    for (i = 0 ; i < 10000000 ; i++){
        uint32_t rand = random_in_range(0,n - 1);
        if(rand >= n){
            printf("bug: rand out of range %u\n",(unsigned int)rand);
            return 1;
        }
        numbers[rand] += 1;
    }

    for(i = 0; i < n; i++) {
        printf("%u: %u\n",i,numbers[i]);
    }

}

Renvoie un nombre à virgule flottante dans la plage [0,1]:

#define rand01() (((double)random())/((double)(RAND_MAX)))