Dieser Header führt Funktionen zur Zufallszahlengenerierung ein. Diese Bibliothek ermöglicht die Erzeugung von Zufallszahlen mithilfe von Kombinationen aus Generatoren und Verteilungen.

Generatoren: Objekte, die gleichmäßig verteilte Zahlen erzeugen.
• Verteilungen : Objekte, die von einem Generator generierte Zahlenfolgen in Zahlenfolgen umwandeln, die einer bestimmten Zufallsvariablenverteilung folgen, z. B. einer einheitlichen Normalverteilung oder einer Binomialverteilung.

Generatoren

I. Pseudozufallszahlen-Engines: Sie verwenden einen Algorithmus, um Zufallszahlen basierend auf einem anfänglichen Startwert zu generieren. Diese sind:

1. linear_kongruential_engine : Es ist die einfachste Engine in der STL-Bibliothek, die zufällige vorzeichenlose Ganzzahlen generiert. Daraus folgt: 

Java-Arraylist-Methoden

 x = (a.x +c) mod m Where x= current state value a = multiplier parameter ; if m is not zero this parameter should be lower than m. c = increment parameter ; if m is not zero this parameter should be lower than m. m = modulus parameter 

Operator():Es generiert eine Zufallszahl.min:Es gibt den Mindestwert an, der vom Mitgliedsoperator() zurückgegeben wird.max:Es gibt den Maximalwert an, der vom Mitgliedsoperator() zurückgegeben wird.

// C++ program to illustrate // the use of operator() max and min // in linear_congruential_engine #include    #include  #include  using namespace std; // driver program int main () {  // finds the time between the system clock  //(present time) and clock's epoch  unsigned seed = chrono::system_clock::now().time_since_epoch().count();    // minstd_rand0 is a standard  // linear_congruential_engine  minstd_rand0 generator (seed);     // generates the random number  cout << generator() << ' is a random number between ';    //use of min and max functions  cout << generator.min() << ' and ' << generator.max();    return 0; } 

Ausgabe:

211182246 is a random number between 1 and 2147483646

2. mersenne_twister_engine: Es handelt sich um eine Zufallszahlen-Engine, die auf dem Mersenne-Twister-Algorithmus basiert. Es erzeugt hochwertige vorzeichenlose ganzzahlige Zufallszahlen im Intervall [0 (2^w)-1].
Dabei ist „w“ die Wortgröße: Anzahl der Bits jedes Wortes in der Zustandssequenz. 

Operator():Es generiert die Zufallszahl.min:Es gibt den vom Mitglied „operator()“ zurückgegebenen Mindestwert zurück, der für „mersenne_twister_engine“ immer Null ist.max:Es gibt den vom Mitglied „operator()“ zurückgegebenen Maximalwert zurück, der für mersenne_twister_engine 2w-1 beträgt (wobei w die Wortgröße ist).

// C++ program to illustrate the use of  // operator() min and max // in mersenne_twister_engine  #include    #include  #include  using namespace std; // Driver program int main () {    // finds the time between the system clock  // (present time) and clock's epoch  unsigned seed = chrono::system_clock::now().time_since_epoch().count();    // mt19937 is a standard mersenne_twister_engine  mt19937 generator (seed);     // use of operator()   cout << generator() << ' is a random number between ';    // use of max and min  cout << generator.min() << ' and ' << generator.max();    return 0; } 

Ausgabe:

3348201622 is a random number between 0 and 4294967295

3. subtract_with_carry_engine: Es handelt sich um eine Pseudozufallszahlengenerator-Engine, die vorzeichenlose Ganzzahlen erzeugt.
Der verwendete Algorithmus ist verzögert Fibonacci-Generator mit einer Zustandsfolge von r ganzzahligen Elementen plus einem Übertragswert.

Operator(): Es generiert die Zufallszahl.max: Es gibt den vom Mitgliedsoperator() zurückgegebenen Maximalwert zurück, der (2^w)-1 für subtract_with_carry_engine ist, wobei „w“ die Wortgröße ist.min: Es gibt den vom Mitgliedsoperator() zurückgegebenen Mindestwert zurück, der für subtract_with_carry_engine immer Null ist.

// C++ program to illustrate the use of  // operator() min and max // in subtract_with_carry_engine #include    #include  #include  using namespace std; // Driver program int main () {    // finds the time between the system clock  // (present time) and clock's epoch  unsigned seed = chrono::system_clock::now().time_since_epoch().count();    subtract_with_carry_engine<unsigned 24 10 24> generator (seed);    // use of operator()  cout << generator() << ' is a random number between ';    // use of min and max  cout << generator.min() << ' and ' << generator.max();  return 0; } 

Ausgabe:

8606455 is a random number between 0 and 16777215

II. Zufallszahlengenerator : Es handelt sich um einen Zufallszahlengenerator, der nichtdeterministische Zufallszahlen erzeugt.

TCP-IP-Modell

random_device: Es ist der echte Zufallszahlengenerator.Operator(): Es wird eine neue Zufallszahl zurückgegeben.min: Es gibt den vom Mitgliedsoperator() zurückgegebenen Mindestwert zurück, der für random_device immer Null ist.max: Es gibt den Maximalwert zurück, der vom Mitgliedsoperator() zurückgegeben wird.

// C++ program to illustrate the use of  // operator() min and max // in random_device  #include    #include  using namespace std; //Driver program int main () {  random_device example;    cout << 'default random_device characteristics:' << endl;    // use of min  cout << 'minimum: ' << example.min() << endl;    // use of max  cout << 'maximum: ' << example.max() << endl;    // use of entropy  cout << 'entropy: ' << example.entropy() << endl;    // use of operator()  cout << 'a random number: ' << example() << endl;    return 0; } 

Ausgabe:

default random_device characteristics: minimum: 0 maximum: 4294967295 entropy: 0 a random number: 3705944883

III. Pseudozufallszahlen-Engines (Instantiierungen) : Dies sind die besonderen Instanziierungen von Generatormotoren und Adaptern:

1. default_random_engine : Dies ist eine Zufallszahlen-Engine-Klasse, die Pseudozufallszahlen generiert.

min: Es gibt den durch „operator()“ angegebenen Mindestwert zurück.max: Es gibt den von „operator()“ angegebenen Maximalwert zurück.Operator(): Es wird eine neue Zufallszahl zurückgegeben.
Die Funktion ändert den internen Zustand um eins, wodurch der Zustandswert gemäß dem angegebenen Algorithmus geändert wird:

 x= (a.x + c)mod m Where x= current state value a and c = respective class template parameters m = class template parameter 

// C++ program to illustrate the use of  // operator() min and max  // in default_random_engine  #include     #include   #include   using namespace std;    // Driver program  int main ()  {     // finds the time between the system clock   // (present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();     // minstd_rand0 is a standard linear_congruential_engine   minstd_rand0 generator (seed);     // generates the random number   cout << generator() << ' is a random number between ';     // Use of min and max   cout << generator.min() << ' and ' << generator.max();     return 0;  }  

Ausgabe:

201066682 is a random number between 1 and 2147483646

2. minstd_rand: Es generiert Pseudozufallszahlen; es ist ähnlich linearer Kongruenzgenerator

Operator():Es gibt eine neue Zufallszahl zurück. Die Funktion ändert den internen Status um eins, wodurch der Statuswert gemäß dem folgenden Algorithmus geändert wird:

x = (a.x + c) mod m where x= current state value a c and m=class template parameter

min:Es gibt den vom Member-Operator() angegebenen Mindestwert zurück.max:Es gibt den vom Mitglied „operator()“ angegebenen Maximalwert zurück, der für linear_congruential_engine (Modulus-1) ist.

// C++ program to illustrate  // the use of operator() max and min  // in minstd_rand  #include     #include   #include   using namespace std;    //Driver program  int main ()  {     // finds the time between the system clock   //(present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();     // minstd_rand0 is a standard   //linear_congruential_engine   minstd_rand0 generator (seed);     // use of operator()   cout << generator() << ' is a random number between ';     //use of max and min   cout << generator.min() << ' and ' << generator.max();     return 0;  } 

Ausgabe:

489592737 is a random number between 1 and 2147483646

3.MT19937: Es handelt sich um den Mersenne Twister 19937-Generator. Es handelt sich um einen Pseudozufallsgenerator für 32-Bit-Zahlen mit einer Zustandsgröße von 19937 Bits.

Operator():Es generiert eine Zufallszahl. Die Funktion ändert den internen Zustand um eins mithilfe eines Übergangsalgorithmus, der eine Drehung des ausgewählten Elements erzeugt.max:Es gibt den von „operator()“ angegebenen Maximalwert zurück.min:Es gibt den von „operator()“ angegebenen Mindestwert zurück.
 

// C++ program to illustrate the  // use of operator()min and max  // in mt19937  #include     #include   #include   using namespace std;    // Driver program  int main ()  {     // finds the time between the system clock   //(present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();     // mt19937 is a standard   //mersenne_twister_engine   mt19937 generator (seed);     //use of operator()   cout << generator() << ' is a random number between ';     //use of max and min   cout << generator.min() << ' and ' << generator.max();     return 0;  } 

Ausgabe:

1445431990 is a random number between 0 and 4294967295

4. ranlux24_base: Es handelt sich um einen Ranlux 24-Basisgenerator. Dabei handelt es sich um einen Subtrahierer mit Übertrags-Pseudozufallsgenerator für 24-Bit-Zahlen, der im Allgemeinen als Basis-Engine für den ranlux24-Generator verwendet wird.

Operator():Es gibt eine neue Zufallszahl zurück.
Die Funktion ändert den internen Zustand, indem sie ihren Übergangsalgorithmus aufruft, der eine Subtraktion mit Übertrag auf das Element anwendet.max:Es gibt den von „operator()“ angegebenen Maximalwert zurück.min:Es gibt den von „operator()“ angegebenen Mindestwert zurück.

// C++ program to illustrate  // the use of operator()min and max  // in ranlux24_base  #include     #include   #include   using namespace std;    //Driver program  int main ()  {     // finds the time between the system clock   //(present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();   subtract_with_carry_engine<unsigned241024> generator (seed);     //use of operator()   cout << generator() << ' is a random number between ';     //use of max and min   cout << generator.min() << ' and ' << generator.max();     return 0;  }  

Ausgabe:

7275352 is a random number between 0 and 16777215

Ein ähnliches Format gilt für die anderen Beispiele.

Konvertieren Sie einen booleschen Wert in einen String

IV. Motoradapter

1. Discard_block_engine: Es handelt sich um eine Engine-Adapter-Klassenvorlage, die a anpasst Pseudozufallszahlengenerator-Engine Geben Sie einen Typ ein, indem Sie nur „r“-Elemente jedes Blocks von „p“-Elementen aus der von ihm erzeugten Sequenz verwenden und den Rest verwerfen.
Der Adapter zählt intern, wie viele Elemente im aktuellen Block erzeugt wurden.

Die Standardgeneratoren ranlux24 Und ranlux48 anpassen a subtract_with_carry_engine mit diesem Adapter.

Operator():Es gibt eine neue Zufallszahl zurück.max:Es gibt den von „operator()“ angegebenen Maximalwert zurück.min:Es gibt den von „operator()“ angegebenen Mindestwert zurück.

// C++ program to illustrate  // the use of operator()min and max  // in the discard_block_engine  #include     #include   #include   using namespace std;    //Driver program  int main ()  {     // finds the time between the system clock   //(present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();     // ranlux24 is a standard instantiation   //of discard_block_engine:   ranlux24 generator (seed);     //use of operator()   cout << generator() << ' is a random number between ';     //use of max and min   cout << generator.min() << ' and ' << generator.max();     return 0;  }  

Ausgabe:

leere Liste Java

8132325 is a random number between 0 and 16777215

2. independent_bits_engine: Es handelt sich um eine Engine-Adapter-Klassenvorlage, die a anpasst Pseudozufallszahlengenerator-Engine Typ, um Zufallszahlen mit einer bestimmten Anzahl von Bits (w) zu erzeugen.

Operator():Es gibt eine neue Zufallszahl zurück.
Der Übergangsalgorithmus der Engine ruft den Operator()-Member der Basis-Engine so oft wie nötig auf, um genügend signifikante Bits zum Erstellen eines Zufallswerts zu erhalten.max:Es gibt den von „operator()“ angegebenen Maximalwert zurück.min:Es gibt den von „operator()“ angegebenen Mindestwert zurück.

// C++ program to illustrate  // the use of operator()min and max  // in independent_bits_engine  #include     #include     // It imports the symbol names in  // std namespace and possibly in Global namespace.  #include   #include   using namespace std;    //Driver program  int main ()  {     // finds the time between the system clock   //(present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();     //use of independent_bits_engine   independent_bits_engine<mt1993764uint_fast64_t> generator (seed);     //use of operator()   cout << generator() << ' is a random number between ';     //use of max and min   cout << generator.min() << ' and ' << generator.max();     return 0;  }  

Ausgabe:

13551674127875514537 is a random number between 0 and 184467

3. shuffle_order_engine: Es handelt sich um eine Engine-Adapter-Klassenvorlage, die a anpasst Pseudozufallszahlengenerator-Engine Geben Sie so ein, dass die Nummern in einer anderen Reihenfolge geliefert werden.
Das Objekt speichert intern einen Puffer mit k generierten Zahlen und gibt bei Anforderung eine zufällig ausgewählte Zahl im Puffer zurück und ersetzt diese durch einen von seiner Basis-Engine erhaltenen Wert.

Operator():Es gibt eine neue Zufallszahl zurück.
Der Übergangsalgorithmus der Engine wählt einen Wert in der internen Tabelle (der von der Funktion zurückgegeben wird) und ersetzt ihn durch einen neuen Wert, der von der Basis-Engine erhalten wurde.max:Es gibt den von „operator()“ angegebenen Maximalwert zurück.min:Es gibt den von „operator()“ angegebenen Mindestwert zurück.

// C++ program to illustrate  // the use of operator()min and max  // in shuffle_order_engine  #include     #include   #include   using namespace std;    int main ()  {     // finds the time between the system clock   //(present time) and clock's epoch   unsigned seed = chrono::system_clock::now().time_since_epoch().count();     // ranlux24 is a standard instantiation   // of discard_block_engine:   ranlux24 generator (seed);     //use of operator()   cout << generator() << ' is a random number between ';     //use of max and min   cout << generator.min() << ' and ' << generator.max();     return 0;  }  

Ausgabe:

9213395 is a random number between 0 and 16777215