Deze header introduceert faciliteiten voor het genereren van willekeurige getallen. Deze bibliotheek maakt het mogelijk willekeurige getallen te produceren met behulp van combinaties van generatoren en distributies.

Generatoren: Objecten die uniform verdeelde getallen genereren.
• Uitkeringen : Objecten die door een generator gegenereerde reeksen getallen transformeren in reeksen getallen die een specifieke verdeling van willekeurige variabelen volgen, zoals uniform Normaal of Binomiaal.

Generatoren

I. Pseudo-willekeurige nummer-engines: Ze gebruiken een algoritme om willekeurige getallen te genereren op basis van een eerste zaadje. Dit zijn:

1. lineaire_congruentiële_engine : Het is de eenvoudigste engine in de STL-bibliotheek die willekeurige gehele getallen zonder teken genereert. Het volgt: 

netwerktopologieën

 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():Het genereert een willekeurig getal.min:Het geeft de minimumwaarde die wordt geretourneerd door member operator().maximaal:Het geeft de maximale waarde die wordt geretourneerd door member operator().

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

Uitgang:

211182246 is a random number between 1 and 2147483646

2. mersenne_twister_engine: Het is een willekeurige nummer-engine gebaseerd op het Mersenne Twister-algoritme. Het produceert willekeurige getallen zonder teken van hoge kwaliteit in het interval [0 (2^w)-1].
waarbij 'w' de woordgrootte is: aantal bits van elk woord in de statusreeks. 

operator():Het genereert het willekeurige getal.min:Het retourneert de minimumwaarde die wordt geretourneerd door member operator(), die voor mersenne_twister_engine altijd nul is.maximaal:Het retourneert de maximale waarde die wordt geretourneerd door member operator(), die voor mersenne_twister_engine 2w-1 is (waarbij w de woordgrootte is).

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

Uitgang:

3348201622 is a random number between 0 and 4294967295

3. aftrekken_met_carry_engine: Het is een pseudo-willekeurige getalgenerator die gehele getallen zonder teken produceert.
Het gebruikte algoritme is vertraagd fibonacci-generator met een toestandsreeks van r gehele elementen plus één carry-waarde.

exploitant(): Het genereert het willekeurige getal.maximaal: Het retourneert de maximale waarde die wordt geretourneerd door member operator(), namelijk (2^w)-1 voor subtract_with_carry_engine waarbij 'w' de woordgrootte is.min: Het retourneert de minimumwaarde die wordt geretourneerd door member operator(), die altijd nul is voor subtract_with_carry_engine.

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

Uitgang:

8606455 is a random number between 0 and 16777215

II. Willekeurige nummergenerator : Het is een generator voor willekeurige getallen die niet-deterministische willekeurige getallen produceert.

willekeurig_apparaat: Het is de echte generator van willekeurige getallen.exploitant(): Er wordt een nieuw willekeurig getal geretourneerd.min: Het retourneert de minimumwaarde die wordt geretourneerd door member operator(), die voor random_device altijd nul is.maximaal: Het retourneert de maximale waarde die wordt geretourneerd door member operator().

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

Uitgang:

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

III. Pseudo-willekeurige nummer-engines (instantiaties) : Dit zijn de specifieke instantiaties van generatormotoren en adapters:

100 km/u naar mph

1. standaard_random_engine : Dit is een klasse voor willekeurige getallen die pseudo-willekeurige getallen genereert.

min: Het retourneert de minimumwaarde gegeven door operator().maximaal: Het retourneert de maximale waarde gegeven door operator().exploitant(): Er wordt een nieuw willekeurig getal geretourneerd.
De functie verandert de interne status met één die de statuswaarde wijzigt volgens het gegeven algoritme:

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

Uitgang:

201066682 is a random number between 1 and 2147483646

2. minstd_rand: Het genereert pseudo-willekeurige getallen; het is vergelijkbaar met lineaire congruentiële generator

operator():Het retourneert een nieuw willekeurig getal. De functie verandert de interne status met één, waardoor de statuswaarde wordt gewijzigd volgens het volgende algoritme:

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

min:Het retourneert de minimumwaarde die is opgegeven door member operator().maximaal:Het retourneert de maximale waarde gegeven door member operator() die voor linear_congruential_engine (modulus-1) is.

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

Uitgang:

c++ gui

489592737 is a random number between 1 and 2147483646

3.MT19937: Het is een Mersenne Twister 19937-generator. Het is een pseudo-willekeurige generator van 32-bits getallen met een statusgrootte van 19937 bits.

operator():Het genereert een willekeurig getal. De functie verandert de interne status met één met behulp van een overgangsalgoritme dat een draai aan het geselecteerde element produceert.maximaal:Het retourneert de maximale waarde gegeven door operator().min:Het retourneert de minimumwaarde gegeven door operator().
 

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

Uitgang:

1445431990 is a random number between 0 and 4294967295

4. ranlux24_base: Het is een Ranlux 24-basisgenerator. Het is een subtract-with-carry pseudo-willekeurige generator van 24-bits getallen die doorgaans wordt gebruikt als de basisengine voor de ranlux24-generator.

operator():Het retourneert een nieuw willekeurig getal.
De functie verandert de interne toestand door het transitiealgoritme aan te roepen, dat een aftrek-met-draagbewerking op het element toepast.maximaal:Het retourneert de maximale waarde gegeven door operator().min:Het retourneert de minimumwaarde gegeven door operator().

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

Uitgang:

7275352 is a random number between 0 and 16777215

Een soortgelijk formaat is van toepassing op de andere voorbeelden.

IV. Motoradapters

1. verwijder_blok_engine: Het is een klassesjabloon voor motoradapters die een pseudo-willekeurige nummergenerator-engine type door alleen 'r'-elementen te gebruiken van elk blok met 'p'-elementen uit de reeks die het produceert, waarbij de rest wordt weggegooid.
De adapter houdt intern bij hoeveel elementen er in het huidige blok zijn geproduceerd.

De standaardgeneratoren ranlux24 En ranlux48 een aanpassen aftrekken_met_carry_engine met behulp van deze adapter.

operator():Het retourneert een nieuw willekeurig getal.maximaal:Het retourneert de maximale waarde gegeven door operator().min:Het retourneert de minimumwaarde gegeven door operator().

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

Uitgang:

8132325 is a random number between 0 and 16777215

2. onafhankelijke_bits_engine: Het is een klassesjabloon voor motoradapters die een pseudo-willekeurige nummergenerator-engine type om willekeurige getallen te produceren met een specifiek aantal bits (w).

operator():Het retourneert een nieuw willekeurig getal.
Het overgangsalgoritme van de engine roept het operator()-lid van de basisengine zo vaak aan als nodig is om voldoende significante bits te verkrijgen om een ​​willekeurige waarde te construeren.maximaal:Het retourneert de maximale waarde gegeven door operator().min:Het retourneert de minimumwaarde gegeven door operator().

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

Uitgang:

panda's iterrijen

13551674127875514537 is a random number between 0 and 184467

3. shuffle_order_engine: Het is een klassesjabloon voor motoradapters die een pseudo-willekeurige nummergenerator-engine typ zodat de nummers in een andere volgorde worden afgeleverd.
Het object houdt intern een buffer van k gegenereerde getallen bij en retourneert op verzoek een willekeurig geselecteerd getal binnen de buffer en vervangt dit door een waarde verkregen uit de basisengine.

operator():Het retourneert een nieuw willekeurig getal.
Het overgangsalgoritme van de engine kiest een waarde in de interne tabel (die wordt geretourneerd door de functie) en vervangt deze door een nieuwe waarde die is verkregen uit de basisengine.maximaal:Het retourneert de maximale waarde gegeven door operator().min:Het retourneert de minimumwaarde gegeven door operator().

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

Uitgang:

9213395 is a random number between 0 and 16777215