Provided by: manpages-fr-dev_2.64.1-1_all bug

NOM

       rand, rand_r, srand - Générateur de nombres pseudo-aléatoires.

SYNOPSIS

       #include <stdlib.h>

       int rand (void);

       int rand_r(unsigned int *seedp);

       void srand (unsigned int seed);

   Exigences  pour les macros de test de fonctionnalité de la glibc (consultez
   feature_test_macros(7)) :

       rand_r() : _POSIX_C_SOURCE || _XOPEN_SOURCE

DESCRIPTION

       La fonction rand()  renvoie  un  entier  pseudo-aléatoire  entre  0  et
       RAND_MAX.

       La  fonction  srand()  utilise  son  argument  comme « graine » pour la
       génération d’une nouvelle séquence de  nombres  pseudo-aléatoires,  qui
       seront  fournis  par  rand().  Ces  séquences  sont  reproductibles  en
       appelant srand() avec la même valeur de graine.

       Si aucune graine originale n’est fournie, la fonction  rand()  commence
       en utilisant la valeur 1.

       La fonction rand() n’est ni réentrante ni sûre en contexte multithread,
       car elle utilise un état interne modifié à chaque appel. Il peut s’agir
       simplement de la valeur de graine aléatoire pour l’appel suivant, ou il
       peut s’agir de quelque chose  de  plus  compliqué.  Afin  d’obtenir  un
       comportement  reproductible  dans une application multithread, cet état
       doit être stocké dans une variable fournie explicitement.  La  fonction
       rand_r()  est  appelée avec un pointeur sur un unsigned int qui servira
       d’état d’interne. Il s’agit d’une donnée très petite  pour  stocker  la
       valeur  d’état, cette fonction sera donc un générateur pseudo-aléatoire
       faible. Essayez donc drand48_r(3) à sa place.

VALEUR RENVOYÉE

       Les fonctions rand() et rand_r() renvoient un nombre entier entre 0  et
       RAND_MAX. La fonction srand() ne renvoie aucune valeur.

CONFORMITÉ

       Les  fonctions  rand()  et srand() sont conformes à SVr4, BSD 4.3, C89,
       C99, POSIX.1-2001. La fonction rand_r() vient de POSIX.1-2001.

NOTES

       Les versions de rand()  et  srand()  de  la  bibliothèque  C  de  Linux
       utilisent  le  même  générateur  de nombres aléatoires que random(3) et
       srandom(3),  ainsi  les  bits  de  poids  faibles   sont   tout   aussi
       imprévisibles  que  les bits de poids forts. Ceci n’est pas le cas avec
       les anciennes implémentations de rand() ou d’actuelles  implémentations
       sur des systèmes différents, où les bits de poids faibles n’étaient pas
       « aussi aléatoires » que ceux de  poids  forts.  N’utilisez  pas  cette
       fonction dans des applications conçues pour être portables et lorsqu’un
       bon caractère aléatoire est nécessaire.

       Dans Numerical Recipes in C: The Art of Scientific  Computing  (William
       H.  Press, Brian P. Flannery, Saul A. Teukolsky, William T. Vetterling;
       New York: Cambridge University  Press,  1990  (1st  ed,  p.  207)),  le
       commentaire suivant apparaît :
              « Si  vous  désirez engendrer un entier aléatoire entre 1 et 10,
              vous devez toujours procéder en  utilisant  les  bits  de  poids
              forts, comme dans :

                     j = 1 + (int) (10.0 * (rand() / (RAND_MAX + 1.0)));

              et jamais ainsi :

                     j = 1 + (rand() % 10);

              (car   cette   dernière   version  utilise  les  bits  de  poids
              faibles). »

       La génération de nombres aléatoires est un domaine complexe.  Le  livre
       Numerical  Recipes  in  C  (référence ci-dessus) fournit une excellente
       présentation pratique d’un générateur  aléatoire  dans  le  chapitre  1
       (Random Numbers).

       Pour  une discussion plus théorique, qui aborde également en profondeur
       d’autres domaines, voir le chapitre 3  (Random  Numbers)  du  livre  de
       Donald   E.   Knuth   The   Art   of  Computer  Programming,  volume  2
       (Seminumerical   Algorithms),   2nd   ed.;   Reading,    Massachusetts:
       Addison-Wesley Publishing Company, 1981.

EXEMPLE

       POSIX.1-2001  fournit  l’exemple suivant d’une implémentation de rand()
       et srand(),  potentiellement  utile  lorsqu’on  a  besoin  de  la  même
       séquence sur deux machines différentes.

           static unsigned long suivant = 1;

           /* RAND_MAX supposé être égal à 32767 */
           int mon_rand(void) {
               suivant = suivant * 1103515245 + 12345;
               return((unsigned)(suivant/65536) % 32768);
           }

           void mon_srand(unsigned graine) {
               suivant = graine;
           }

VOIR AUSSI

       drand48(3), random(3)

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement         gérées         par         Nicolas         François
       <nicolas.francois@centraliens.net>   et   l’équipe    francophone    de
       traduction de Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».

                                26 juillet 2007                        RAND(3)