random(3)                  Library Functions Manual                  random(3)

NUME
       random, srandom, initstate, setstate - generator de numere aleatoare

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

REZUMAT
       #include <stdlib.h>

       long random(void);
       void srandom(unsigned int seed);

       char *initstate(unsigned int seed, char state[.n], size_t n);
       char *setstate(char *state);

   Cerin<?>e pentru macrocomenzi de testare a caracteristicilor pentru glibc
   (consulta<?>i feature_test_macros(7)):

       random(), srandom(), initstate(), setstate():
           _XOPEN_SOURCE >= 500
               || /* glibc >= 2.19: */ _DEFAULT_SOURCE
               || /* glibc <= 2.19: */ _SVID_SOURCE || _BSD_SOURCE

DESCRIERE
       Func<?>ia random() utilizeaza un generator de numere aleatoare cu
       reac<?>ie aditiva neliniara care utilizeaza un tabel implicit de 31 de
       numere intregi lungi pentru a returna numere pseudoaleatoare succesive
       in intervalul 0-2^31 - 1. Perioada acestui generator de numere
       aleatoare este foarte mare, aproximativ 16 * ((2^31) - 1).

       Func<?>ia srandom() i<?>i stabile<?>te argumentul ca saman<?>a pentru o
       noua secven<?>a de numere intregi pseudoaleatoare care va fi returnata
       de random(). Aceste secven<?>e pot fi repetate prin apelarea srandom()
       cu aceea<?>i valoare de saman<?>a. In cazul in care nu se furnizeaza
       nicio valoare de saman<?>a, func<?>ia random() este automat
       insaman<?>ata cu o valoare de 1.

       Func<?>ia initstate() permite ini<?>ializarea unei matrice de stari
       state pentru a fi utilizata de random(). Dimensiunea matricei de stare
       n este utilizata de initstate() pentru a decide cat de sofisticat
       trebuie sa fie generatorul de numere aleatoare pe care trebuie sa-l
       utilizeze - cu cat matricea de stare este mai mare, cu atat mai bune
       vor fi numerele aleatoare. Valorile ,,optime" actuale pentru
       dimensiunea matricei de stari n sunt 8, 32, 64, 128 <?>i 256 de
       octe<?>i; alte valori vor fi rotunjite la cea mai apropiata valoare
       cunoscuta. Daca se utilizeaza mai pu<?>in de 8 octe<?>i, se produce o
       eroare. seed este saman<?>a pentru ini<?>ializare, care specifica un
       punct de pornire pentru secven<?>a de numere aleatoare <?>i asigura
       repornirea in acela<?>i punct.

       Func<?>ia setstate() modifica matricea de stare utilizata de func<?>ia
       random(). Matricea de stare state este utilizata pentru generarea
       numerelor aleatoare pana la urmatorul apel al func<?>iei initstate()
       sau setstate(). state trebuie mai intai sa fi fost ini<?>ializat cu
       ajutorul initstate() sau sa fie rezultatul unui apel anterior al
       setstate().

VALOAREA RETURNATA
       Func<?>ia random() returneaza o valoare intre 0 <?>i (2^31) - 1.
       Func<?>ia srandom() nu returneaza nicio valoare.

       Func<?>ia initstate() returneaza un indicator la matricea de stare
       anterioara. In caz de e<?>ec, aceasta returneaza NULL, iar errno este
       configurata pentru a indica eroarea.

       In caz de succes, setstate() returneaza un indicator la matricea de
       stare anterioara. In caz de e<?>ec, aceasta returneaza NULL, iar errno
       este configurata pentru a indica eroarea.

ERORI-IE<?>IRE
       EINVAL Argumentul state dat la setstate() a fost NULL.

       EINVAL O matrice de stare mai mica de 8 octe<?>i a fost specificata la
              initstate().

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +--------------------------------------+---------------------+---------+
       |Interfa<?>a                           | Atribut             | Valoare |
       +--------------------------------------+---------------------+---------+
       |random(), srandom(), initstate(),     | Siguran<?>a firelor | MT-Safe |
       |setstate()                            |                     |         |
       +--------------------------------------+---------------------+---------+
STANDARDE
       POSIX.1-2008.

ISTORIC
       POSIX.1-2001, 4.3BSD.

NOTE
       Generarea numerelor aleatoare este un subiect complex. 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, 2007, ed. a 3-a) ofera o discu<?>ie
       excelenta a problemelor practice de generare a numerelor aleatoare in
       capitolul 7 (Random Numbers).

       Pentru o discu<?>ie mai teoretica, care acopera in profunzime <?>i
       multe aspecte practice, a se vedea capitolul 3 (Random Numbers) din The
       Art of Computer Programming Donald E. Knuth's, volumul 2 (Seminumerical
       Algorithms), 2nd ed.; Reading, Massachusetts: Addison-Wesley Publishing
       Company, 1981.

PRECAU<?>II
       Func<?>ia random() nu ar trebui utilizata in programele cu mai multe
       fire de execu<?>ie in care este necesar un comportament reproductibil.
       Folosi<?>i random_r(3) in acest scop.

ERORI
       In conformitate cu POSIX, initstate() ar trebui sa returneze NULL in
       caz de eroare. In implementarea glibc, errno este (a<?>a cum este
       specificat) stabilita in caz de eroare, dar func<?>ia nu returneaza
       NULL.

CONSULTA<?>I <?>I
       getrandom(2), drand48(3), rand(3), random_r(3), srand(3)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.06 31 octombrie 2023                     random(3)