This manual page is part of the POSIX Programmer's Manual. The Linux implementation of this interface

       The drand48() and random() 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
       rand_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.

       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(3POSIX)

       For  rand()  and  srand():  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 rand() function shall compute a sequence of pseudo-random integers in the range [0,{RAND_MAX}] with a
       period of at least 232.

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

       The  rand_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 rand_r() is called with the same initial value for the object pointed to by seed and  that  object  is
       not modified between successive returns and calls to rand_r(), the same sequence shall be generated.

       The  srand()  function  uses  the  argument  as  a seed for a new sequence of pseudo-random numbers to be
       returned by subsequent calls to rand().  If srand() is then called with the same seed value, the sequence
       of pseudo-random numbers shall be repeated. If rand() is called before any calls to srand() are made, the
       same sequence shall be generated as when srand() 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 rand()  or
       srand().

       No errors are defined.

       Thefollowingsectionsareinformative.

GeneratingaPseudo-RandomNumberSequence
       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;
               }

   GeneratingtheSameSequenceonDifferentMachines
       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;
           }

       The rand_r() function may be removed in a future version.

       rand, rand_r, srand — pseudo-random number generator

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

       The ISO C standard rand() and srand() 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 rand(), 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 rand()

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

       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 rand() function implementations, which have been
       approached by maintaining more state. In effect, this specifies new  thread-safe  forms  of  a  deficient
       function.

       The rand() function shall return the next pseudo-random number in the sequence.

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

       The srand() function shall not return a value.

drand48(), initstate()

       The Base Definitions volume of POSIX.1‐2017, <stdlib.h>

       #include <stdlib.h>

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