RAND(3)                    POSIX Programmer's Manual                   RAND(3)



PPRROOLLOOGG
       This manual page is part of the POSIX Programmer's Manual.  The OS
       implementation of this interface may differ (consult the corresponding
       OS manual page for details of OS behavior), or the interface may not be
       implemented on OS.

NNAAMMEE
       rand, rand_r, srand -- pseudo-random number generator

SSYYNNOOPPSSIISS
       #include <stdlib.h>

       int rand(void);
       int rand_r(unsigned *_s_e_e_d);
       void srand(unsigned _s_e_e_d);

DDEESSCCRRIIPPTTIIOONN
       For _r_a_n_d() and _s_r_a_n_d(): The functionality described on this reference
       page is aligned with the ISO C standard. Any conflict between the
       requirements described here and the ISO C standard is unintentional.
       This volume of POSIX.1-2017 defers to the ISO C standard.

       The _r_a_n_d() function shall compute a sequence of pseudo-random integers
       in the range [0,{RAND_MAX}] with a period of at least 232.

       The _r_a_n_d() function need not be thread-safe.

       The _r_a_n_d___r() function shall compute a sequence of pseudo-random
       integers in the range [0,{RAND_MAX}].  (The value of the {RAND_MAX}
       macro shall be at least 32767.)

       If _r_a_n_d___r() is called with the same initial value for the object
       pointed to by _s_e_e_d and that object is not modified between successive
       returns and calls to _r_a_n_d___r(), the same sequence shall be generated.

       The _s_r_a_n_d() function uses the argument as a seed for a new sequence of
       pseudo-random numbers to be returned by subsequent calls to _r_a_n_d().  If
       _s_r_a_n_d() is then called with the same seed value, the sequence of
       pseudo-random numbers shall be repeated. If _r_a_n_d() is called before any
       calls to _s_r_a_n_d() are made, the same sequence shall be generated as when
       _s_r_a_n_d() is first called with a seed value of 1.

       The implementation shall behave as if no function defined in this
       volume of POSIX.1-2017 calls _r_a_n_d() or _s_r_a_n_d().

RREETTUURRNN VVAALLUUEE
       The _r_a_n_d() function shall return the next pseudo-random number in the
       sequence.

       The _r_a_n_d___r() function shall return a pseudo-random integer.

       The _s_r_a_n_d() function shall not return a value.

EERRRROORRSS
       No errors are defined.

       _T_h_e _f_o_l_l_o_w_i_n_g _s_e_c_t_i_o_n_s _a_r_e _i_n_f_o_r_m_a_t_i_v_e_.

EEXXAAMMPPLLEESS
   GGeenneerraattiinngg aa PPsseeuuddoo--RRaannddoomm NNuummbbeerr SSeeqquueennccee
       The following example demonstrates how to generate a sequence of
       pseudo-random numbers.


           #include <stdio.h>
           #include <stdlib.h>
           ...
               long count, i;
               char *keystr;
               int elementlen, len;
               char c;
           ...
           /* Initial random number generator. */
               srand(1);

               /* Create keys using only lowercase characters */
               len = 0;
               for (i=0; i<count; i++) {
                   while (len < elementlen) {
                       c = (char) (rand() % 128);
                       if (islower(c))
                           keystr[len++] = c;
                   }

                   keystr[len] = '\0';
                   printf("%s Element%0*ld\n", keystr, elementlen, i);
                   len = 0;
               }

   GGeenneerraattiinngg tthhee SSaammee SSeeqquueennccee oonn DDiiffffeerreenntt MMaacchhiinneess
       The following code defines a pair of functions that could be
       incorporated into applications wishing to ensure that the same sequence
       of numbers is generated across different machines.


           static unsigned long next = 1;
           int myrand(void)  /* RAND_MAX assumed to be 32767. */
           {
               next = next * 1103515245 + 12345;
               return((unsigned)(next/65536) % 32768);
           }

           void mysrand(unsigned seed)
           {
               next = seed;
           }

AAPPPPLLIICCAATTIIOONN UUSSAAGGEE
       The _d_r_a_n_d_4_8() and _r_a_n_d_o_m() functions provide much more elaborate
       pseudo-random number generators.

       The limitations on the amount of state that can be carried between one
       function call and another mean the _r_a_n_d___r() function can never be
       implemented in a way which satisfies all of the requirements on a
       pseudo-random number generator.

       These functions should be avoided whenever non-trivial requirements
       (including safety) have to be fulfilled.

RRAATTIIOONNAALLEE
       The ISO C standard _r_a_n_d() and _s_r_a_n_d() functions allow per-process
       pseudo-random streams shared by all threads. Those two functions need
       not change, but there has to be mutual-exclusion that prevents
       interference between two threads concurrently accessing the random
       number generator.

       With regard to _r_a_n_d(), there are two different behaviors that may be
       wanted in a multi-threaded program:

        1. A single per-process sequence of pseudo-random numbers that is
           shared by all threads that call _r_a_n_d()

        2. A different sequence of pseudo-random numbers for each thread that
           calls _r_a_n_d()

       This is provided by the modified thread-safe function based on whether
       the seed value is global to the entire process or local to each thread.

       This does not address the known deficiencies of the _r_a_n_d() function
       implementations, which have been approached by maintaining more state.
       In effect, this specifies new thread-safe forms of a deficient
       function.

FFUUTTUURREE DDIIRREECCTTIIOONNSS
       The _r_a_n_d___r() function may be removed in a future version.

SSEEEE AALLSSOO
       _d_r_a_n_d_4_8(), _i_n_i_t_s_t_a_t_e()

       The Base Definitions volume of POSIX.1-2017, <<ssttddlliibb..hh>>

CCOOPPYYRRIIGGHHTT
       Portions of this text are reprinted and reproduced in electronic form
       from IEEE Std 1003.1-2017, Standard for Information Technology --
       Portable Operating System Interface (POSIX), The Open Group Base
       Specifications Issue 7, 2018 Edition, Copyright (C) 2018 by the
       Institute of Electrical and Electronics Engineers, Inc and The Open
       Group.  In the event of any discrepancy between this version and the
       original IEEE and The Open Group Standard, the original IEEE and The
       Open Group Standard is the referee document. The original Standard can
       be obtained online at http://www.opengroup.org/unix/online.html .

       Any typographical or formatting errors that appear in this page are
       most likely to have been introduced during the conversion of the source
       files to man page format. To report such errors, see
       https://www.kernel.org/doc/man-pages/reporting_bugs.html .



IEEE/The Open Group                  2017                              RAND(3)
