隨機數生成算法【詳解，歸納】

1、蒙特卡洛方法

蒙特卡羅方法又稱統計模擬法、隨機抽樣技術，是一種隨機模擬方法，以概率和統計理論方法為基礎的一種計算方法，是使用隨機數（或更常見的偽隨機數）來解決很多計算問題的方法。將所求解的問題同一定的概率模型相聯系，用電子計算機實現統計模擬或抽樣，以獲得問題的近似解。為象征性地表明這一方法的概率統計特征，數學家馮·諾依曼用聞名世界的賭城——蒙特卡羅命名（就是那個馮·諾依曼）。
蒙特卡羅方法解題過程的主要步驟：
a.針對實際問題建立一個簡單且便於實現的概率統計模型，使所求的量恰好是該模型的概率分布或數字特征。
b.對模型的隨機變量建立抽樣方法，在計算機上進行模擬測試，抽取足夠多的隨機數。
c.對模擬實驗結果進行統計分析，給出所求解的“估計”。
d.必要時，改進模型以提高估計精度和減少實驗費用，提高模擬效率。

2、馮·諾依曼

馮·諾依曼（John von Neumann，1903~1957），20世紀最重要的數學家之一，在現代計算機、博弈論和核武器等諸多領域內有傑出建樹的最偉大的科學全才之一，被稱為“計算機之父”和“博弈論之父”。主要貢獻是：2進制思想與程序內存思想，當然還有蒙特卡洛方法。通過第一部分，可知，蒙特卡洛方法更多的是一種思想的體現（這點遠不同於快排等“嚴格”類算法），下面介紹最常見的一種應用——隨機數生成。

3、U(0,1)隨機數的產生

對隨機系統進行模擬，便需要產生服從某種分布的一系列隨機數。最常用、最基礎的隨機數是在（0,1）區間內均勻分布的隨機數，最常用的兩類數值計算方法是：乘同余法和混合同余法。

乘同余法：其中，被稱為種子，是模，是（0,1）區間的隨機數。

混合同余法：其中，是非負整數。

這些隨機數是具有周期性的，模擬參數的選擇不同，產生的隨機數質量也有所差異。更復雜的生成方法還有：

4、從U(0,1)到其它概率分布的隨機數

離散型隨機數的模擬

設隨機變量X的概率分布為：，分布函數有

設隨機變量U~U(0,1)的均勻分布，則，表明的概率與隨機變量u落在與之間的概率相同。

例如：離散隨機變量X有分布律

X	0	1	2
P(x)	0.3	0.3	0.4

U是(0,1)的均勻分布，則有，這樣得到的x便具有X的分布律。

連續型隨機變量的模擬

常用的有兩種方法：逆變換法和舍選法。逆變換法
定理：設隨機變量Y的分布函數為F(y)是連續函數，而U是(0,1)上均勻分布的隨機變量。另，則X和Y具有相同的分布。

證明：由定義知，X的分布函數
所以X和Y具有相同的分布。
這樣計算得，帶入均勻分布的U，即可得到服從的隨機數Y。
例如：設X~U(a,b)，則其分布函數為

則。所以生成U(0,1)的隨機數U，則便是來自U(a,b)的隨機數。

有些隨機變量的累計分布函數不存在或者難以求出，即使存在，但計算困難，於是提出了舍選法
要產生服從的隨機數，設x的值域為[a,b]，抽樣過程如下：

1.已知隨機分布且x的取值區間也為[a,b]，並要求，如圖：

2.從中隨機抽樣得，然后由的均勻分布抽樣得。
3.接受或舍棄取樣值，如果舍棄該值；返回上一步，否則接受。幾何解釋如下：

常數c的選取：c應該盡可能地小，因為抽樣效率與c成反比；一般取。這里的可以取均勻分布，這樣由第二步中兩個均勻分布便能得到其他任意分布的模擬抽樣。

5、正態隨機數的生成

除了上面的反函數法和舍選法，正態隨機數還可以根據中心極限定理和Box Muller（坐標變換法）得到。

中心極限定理：如果隨機變量序列 獨立同分布，並且具有有限的數學期望和方差，則對於一切有

也就是說，當n個獨立同分布的變量和，服從的正態分布（n足夠大時）。

設n個獨立同分布的隨機變量，它們服從U(0,1)的均勻分布，那么漸近服從正態分布。

Box Muller方法，設（X,Y）是一對相互獨立的服從正態分布的隨機變量，則有概率密度函數：

令，其中，則有分布函數：

令，則分布函數的反函數得：。

如果服從均勻分布U(0,1)，則可由模擬生成（也為均勻分布，可被代替）。令為，服從均勻分布U(0,1)。得：

X和Y均服從正態分布。用Box Muller方法來生成服從正態分布的隨機數是十分快捷方便的。

下面介紹幾種簡單的隨機數的算法

1 生成隨機數

一般c語言中提供了隨機數生成函數，

其一是偽隨機數--rand：用於返回一個0-32767之間的偽隨機數；

其二是隨機種子函數--srand：用來初始化隨機數發生器的隨機種子

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int i,j;
    srand((int)time(0));
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            printf("%d  ",rand());
        }
        printf("\n");
    }
    return 0;
}

當然也可以生成一定范圍內的隨機數

比如生成0——100之間的隨機數

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int i,j;
    srand((int)time(0));
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            printf("%d  ",rand()*100/32767);
        }
        printf("\n");
    }
    return 0;
}

也可以生成100——200之間的隨機數

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int i,j;
    srand((int)time(0));
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            printf("%d  ",rand()/1000+100);
        }
        printf("\n");
    }
    return 0;
}

使用rand()函數獲取一定范圍內的一個隨機數

如果想要獲取在一定范圍內的數的話，直接做相應的除法取余即可。

#include<iostream>
#include<ctime>
using namespace std;
int main()
{
 srand(time(0));
 for(int i=0;i<10;i++)
 {
  //產生10以內的整數
  cout<<rand()%10<<endl;
 }
}

2 生成[0,1]之間均勻分布的隨機數算法

 

 

 

在這里采用一種方式生成隨機數

其中i=1,2,3.。。。

而pi就是地推倒的第i個隨機數

 

根據經驗，一般選取基數base=256.0,一般為2的整數倍；另外的兩個常數選取a=17.0 和b=139.0

 

需要注意

（1）這里的取模運算是針對浮點型數據的，而c語言中的取模運算不能用於浮點數數據的操作，這樣就需要用戶自己編寫取模的程序；

（2）ri是隨着遞推而每次更新的。因此，如果將這個算法編寫出函數，需要考慮參數是傳值還是傳地址；

 

遞推更新，所以在這里要傳地址，否則得不到結果！

#include <stdio.h>


double rand0_1(double *r)
{
    double base=256.0;
    double a=17.0;
    double b=139.0;
    double temp1=a*(*r)+b;
    //printf("%lf",temp1);
    double temp2=(int)(temp1/base); //得到余數
    double temp3=temp1-temp2*base;
    //printf("%lf\n",temp2);
    //printf("%lf\n",temp3);
    *r=temp3;
    double p=*r/base;
    return p;
}

int main()
{
    double r=5.0;
    printf("output 10 number between 0 and 1:\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%10.5lf\n",rand0_1(&r));
    }
    return 0;
}

3 產生任意范圍內的隨機數，比如產生[m,n]之間的隨機數

這個很容易，只要將之前的[0,1]之間的隨機數這樣處理就行了

m+(m-n)*rand0_1(&r)就行了；

#include <stdio.h>


double rand0_1(double *r)
{
    double base=256.0;
    double a=17.0;
    double b=139.0;
    double temp1=a*(*r)+b;
    //printf("%lf",temp1);
    double temp2=(int)(temp1/base); //得到余數
    double temp3=temp1-temp2*base;
    //printf("%lf\n",temp2);
    //printf("%lf\n",temp3);
    *r=temp3;
    double p=*r/base;
    return p;
}

int main()
{
    double m=1.0,n=5.0;
    double r=5.0;
    printf("output 10 number between 0 and 1:\n");
    for (int i = 0; i < 10; i++)
    {
        printf("%10.5lf\n",m+(n-m)*rand0_1(&r));
    }
    return 0;
}

4 正態分布的隨機數生成算法

 

符合正太分布的隨機數在研究中也很重要，下面給出一種生成正態分布數的方法

 

其中Ri表示[0,1]之間均勻分布的隨機數；

 

u為均值，  為方差，當n趨向於無窮大的時候，得到隨機的隨機分布為正態分布；

#include <stdio.h>
#include <math.h>

double rand0_1(double *r)
{
      double base=256.0;
      double a=17.0;
      double b=139.0;
      double temp1=a*(*r)+b;
      //printf("%lf",temp1);
      double temp2=(int)(temp1/base); //得到余數
      double temp3=temp1-temp2*base;
      //printf("%lf\n",temp2);
      //printf("%lf\n",temp3);
      *r=temp3;
      double p=*r/base;
      return p;
}

double random_normality(double u,double t,double *r ,double n)
{
      double total=0.0;
      double result;
      for (int i = 0; i < n; i++)
      {
            total+=rand0_1(r);
      }
      result=u+t*(total-n/2)/sqrt(n/12);
      return result;
}

int main()
{
      double r=5.0;
      double u=2.0;
      double t=3.5;
      double n=12;
      printf("output 10 number between 0 and 1:\n");
      for (int i = 0; i < 10; i++)
      {
            printf("%10.5lf\n",random_normality(u,t,&r,n));
      }
      return 0;
}

 補充知識點：leveldb中使用了一個簡單的方式來實現隨機化數；算法的核心是seed_ = (seed_ * A) % M,

下面把源代碼貼出來，不難，可以和上面的參考下

private:
  uint32_t seed_;
 public:
  explicit Random(uint32_t s) : seed_(s & 0x7fffffffu) {
    // Avoid bad seeds.
    if (seed_ == 0 || seed_ == 2147483647L) {
      seed_ = 1;
    }
  }
  uint32_t Next() {
    static const uint32_t M = 2147483647L;   // 2^31-1
    static const uint64_t A = 16807;  // bits 14, 8, 7, 5, 2, 1, 0
    // We are computing
    //       seed_ = (seed_ * A) % M,    where M = 2^31-1
    //
    // seed_ must not be zero or M, or else all subsequent computed values
    // will be zero or M respectively.  For all other values, seed_ will end
    // up cycling through every number in [1,M-1]
    uint64_t product = seed_ * A;

    // Compute (product % M) using the fact that ((x << 31) % M) == x.
    seed_ = static_cast<uint32_t>((product >> 31) + (product & M));
    // The first reduction may overflow by 1 bit, so we may need to
    // repeat.  mod == M is not possible; using > allows the faster
    // sign-bit-based test.
    if (seed_ > M) {
      seed_ -= M;
    }
    return seed_;
  }
  // Returns a uniformly distributed value in the range [0..n-1]
  // REQUIRES: n > 0
  uint32_t Uniform(int n) { return Next() % n; }

  // Randomly returns true ~"1/n" of the time, and false otherwise.
  // REQUIRES: n > 0
  bool OneIn(int n) { return (Next() % n) == 0; }

  // Skewed: pick "base" uniformly from range [0,max_log] and then
  // return "base" random bits.  The effect is to pick a number in the
  // range [0,2^max_log-1] with exponential bias towards smaller numbers.
  uint32_t Skewed(int max_log) {
    return Uniform(1 << Uniform(max_log + 1));
  }
};

這里面也直接取模得到一定范圍內的隨機數，簡單明了。

總之，做個簡單的總結

C語言/C++怎樣產生隨機數：這里要用到的是rand()函數, srand()函數,和time()函數。

需要說明的是，iostream頭文件中就有srand函數的定義，不需要再額外引入stdlib.h;而使用time()函數需要引入ctime頭文件。

使用rand()函數獲取一個隨機數
如果你只要產生隨機數而不需要設定范圍的話，你只要用rand()就可以了：rand()會返回一隨機數值, 范圍在0至RAND_MAX 間。RAND_MAX定義在stdlib.h, 其值為2147483647。

使用rand函數和time函數
我們上面已經可以獲取隨機數了，為什么還需要使用time函數呢？我們通過多次運行發現，該程序雖然生成了10個隨機數，但是這個10個隨機數是固定的，也就是說並不隨着時間的變化而變化。

這與srand()函數有關。srand()用來設置rand()產生隨機數時的隨機數種子。在調用rand()函數產生隨機數前，必須先利用srand()設好隨機數種子（seed）, 如果未設隨機數種子, rand()在調用時會自動設隨機數種子為1。

上面的例子就是因為沒有設置隨機數種子，每次隨機數種子都自動設成相同值1 ，進而導致rand()所產生的隨機數值都一樣。

srand()函數定義 ： void srand (unsigned int seed);

通常可以利用geypid()或time(0)的返回值來當做seed

如果你用time(0)的話，要加入頭文件#include<ctime>

time(0)或者time(NULL)返回的是系統的時間（從1970.1.1午夜算起），單位：秒