C++中的随机标头|第一组(发电机)

该头文件介绍了随机数生成工具。该库允许使用生成器和分布的组合来产生随机数。

• 生成器：生成均匀分布的数字的对象。
• 分布：将生成器生成的数字序列转换为遵循特定随机变量分布(例如均匀，正态或二项式)的数字序列的对象。

发电机

I.伪随机数引擎：它们使用一种算法来基于初始种子生成随机数。这些都是：

1. linear_congruential_engine ：这是STL库中最简单的引擎，它生成随机的无符号整数。它跟随：

   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 

   • 运算符()：生成随机数。
   • min：给出成员运算符()返回的最小值。
   • max：给出成员运算符()返回的最大值。

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

   输出：

   211182246 is a random number between 1 and 2147483646
   

2. mersenne_twister_engine：这是一个基于Mersenne Twister算法的随机数引擎。它在区间[0，(2 ^ w)-1]中产生高质量的无符号整数随机数。
   其中“ w”是字长：状态序列中每个字的位数。
   • 运算符()：生成随机数。
   • min：它返回成员运算符()返回的最小值，对于mersenne_twister_engine，该值始终为零。
   • max：返回成员运算符()返回的最大值，对于mersenne_twister_engine，该值为2w-1(其中w为字长)。

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

   输出：

   3348201622 is a random number between 0 and 4294967295
   

3. tractor_with_carry_engine：这是一个伪随机数生成器引擎，可生成无符号整数。
   使用的算法是滞后斐波那契生成器，其状态序列为r个整数元素加上一个进位值。
   • 运算符() ：它生成随机数。
   • max ：它返回成员运算符()返回的最大值，对于减去_with_carry_engine是(2 ^ w)-1，其中’w’是单词size。
   • min ：它返回成员运算符()返回的最小值，对于减去_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 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;
   }
   

   输出：

   8606455 is a random number between 0 and 16777215
   

   二。随机数发生器：这是一个随机数发生器，它产生不确定的随机数。

   • random_device ：它是真正的随机数生成器。
   • 运算符() ：它返回一个新的随机数。
   • min ：它返回成员运算符()返回的最小值，对于random_device始终为零。
   • max ：它返回成员运算符()返回的最大值。

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

   输出：

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

   三，伪随机数引擎(实例化) ：这些是生成器引擎和适配器的特殊实例化：
   

   1. default_random_engine ：这是一个随机数引擎类，可生成伪随机数。
      • min ：返回运算符()给出的最小值。
      • max ：它返回由运算符()给出的最大值。
      • 运算符() ：返回一个新的随机数。
        该函数将内部状态更改为一，然后根据给定的算法修改状态值：

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

      输出：

      201066682 is a random number between 1 and 2147483646
      

   2. minstd_rand：生成伪随机数；它类似于线性同余生成器
      • 运算符()：返回一个新的随机数。该函数将内部状态更改为一，然后根据以下算法修改状态值：

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

      • min：返回成员运算符()给出的最小值。
      • max：返回成员运算符()给出的最大值，linear_congruential_engine的最大值为(modulus-1)。

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

      输出：

      489592737 is a random number between 1 and 2147483646
      

   3. mt19937：它是Mersenne Twister 19937生成器。它是一个32位数字的伪随机数生成器，状态大小为19937位。
      • 运算符()：生成一个随机数。该函数使用转换算法将内部状态改变一个，该算法会在所选元素上产生扭曲。
      • max：返回由运算符()给出的最大值。
      • min：返回运算符()给出的最小值。

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

      输出：

      1445431990 is a random number between 0 and 4294967295
      

   4. ranlux24_base：它是Ranlux 24 base生成器。它是一个24位数字的带进位伪随机生成器，通常用作ranlux24生成器的基本引擎。
      • 运算符()：返回一个新的随机数。
        该函数通过调用其转换算法来更改内部状态，该转换算法对元素应用了带进位减法运算。
      • max：返回由运算符()给出的最大值。
      • min：返回运算符()给出的最小值。

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

      输出：

      7275352 is a random number between 0 and 16777215
      

   类似的格式适用于其他示例。

   IV。引擎适配器
   

   1. reject_block_engine：这是引擎适配器类模板，通过仅使用生成的序列中的“ p”个元素的每个块的“ r”个元素来适应伪随机数生成器引擎类型，从而丢弃其余部分。
      适配器对当前块中已生成的元素数量进行内部计数。
      标准生成器ranlux24和ranlux48使用此适配器来适配减法_带_进位_引擎。
      • 运算符()：返回一个新的随机数。
      • max：返回由运算符()给出的最大值。
      • min：返回运算符()给出的最小值。

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

      输出：

      8132325 is a random number between 0 and 16777215
      

   2. Independent_bits_engine：这是引擎适配器类模板，它适应伪随机数生成器Engine类型，以产生具有特定位数(w)的随机数。
      • 运算符()：返回一个新的随机数。
        引擎的转换算法根据需要调用基本引擎的运算符()成员多次，以获得足够的有效位以构造随机值。
      • max：返回由运算符()给出的最大值。
      • min：返回运算符()给出的最小值。

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

      输出：

      13551674127875514537 is a random number between 0 and 18446744073709551615
      

   3. shuffle_order_engine：这是引擎适配器类模板，它适应伪随机数生成器引擎类型，以便以不同的顺序传递数字。

      该对象在内部保留一个由k个生成的数字组成的缓冲区，并在请求时在缓冲区内返回一个随机选择的数字，并将其替换为从其基本引擎获得的值。

      • 运算符()：返回一个新的随机数。
        引擎的转换算法从内部表中选择一个值(该函数由函数返回)，并将其替换为从其基本引擎获得的新值。
      • max：返回由运算符()给出的最大值。
      • min：返回运算符()给出的最小值。

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

      输出：

      9213395 is a random number between 0 and 16777215
      

   要从最佳影片策划和实践问题去学习，检查了C++基础课程为基础，以先进的C++和C++ STL课程基础加上STL。要完成从学习语言到DS Algo等的更多准备工作，请参阅“完整面试准备课程” 。