随机数生成算法【详解，归纳】

 1 #include <stdio.h>
 2 
 3 
 4 double rand0_1(double *r)
 5 {
 6     double base=256.0;
 7     double a=17.0;
 8     double b=139.0;
 9     double temp1=a*(*r)+b;
10     //printf("%lf",temp1);
11     double temp2=(int)(temp1/base); //得到余数
12     double temp3=temp1-temp2*base;
13     //printf("%lf\n",temp2);
14     //printf("%lf\n",temp3);
15     *r=temp3;
16     double p=*r/base;
17     return p;
18 }
19 
20 int main()
21 {
22     double m=1.0,n=5.0;
23     double r=5.0;
24     printf("output 10 number between 0 and 1:\n");
25     for (int i = 0; i < 10; i++)
26     {
27         printf("%10.5lf\n",m+(n-m)*rand0_1(&r));
28     }
29     return 0;
30 }

 1 #include <stdio.h>
 2 #include <math.h>
 3 
 4 double rand0_1(double *r)
 5 {
 6       double base=256.0;
 7       double a=17.0;
 8       double b=139.0;
 9       double temp1=a*(*r)+b;
10       //printf("%lf",temp1);
11       double temp2=(int)(temp1/base); //得到余数
12       double temp3=temp1-temp2*base;
13       //printf("%lf\n",temp2);
14       //printf("%lf\n",temp3);
15       *r=temp3;
16       double p=*r/base;
17       return p;
18 }
19 
20 double random_normality(double u,double t,double *r ,double n)
21 {
22       double total=0.0;
23       double result;
24       for (int i = 0; i < n; i++)
25       {
26             total+=rand0_1(r);
27       }
28       result=u+t*(total-n/2)/sqrt(n/12);
29       return result;
30 }
31 
32 int main()
33 {
34       double r=5.0;
35       double u=2.0;
36       double t=3.5;
37       double n=12;
38       printf("output 10 number between 0 and 1:\n");
39       for (int i = 0; i < 10; i++)
40       {
41             printf("%10.5lf\n",random_normality(u,t,&r,n));
42       }
43       return 0;
44 }

 1 private:
 2   uint32_t seed_;
 3  public:
 4   explicit Random(uint32_t s) : seed_(s & 0x7fffffffu) {
 5     // Avoid bad seeds.
 6     if (seed_ == 0 || seed_ == 2147483647L) {
 7       seed_ = 1;
 8     }
 9   }
10   uint32_t Next() {
11     static const uint32_t M = 2147483647L;   // 2^31-1
12     static const uint64_t A = 16807;  // bits 14, 8, 7, 5, 2, 1, 0
13     // We are computing
14     //       seed_ = (seed_ * A) % M,    where M = 2^31-1
15     //
16     // seed_ must not be zero or M, or else all subsequent computed values
17     // will be zero or M respectively.  For all other values, seed_ will end
18     // up cycling through every number in [1,M-1]
19     uint64_t product = seed_ * A;
20 
21     // Compute (product % M) using the fact that ((x << 31) % M) == x.
22     seed_ = static_cast<uint32_t>((product >> 31) + (product & M));
23     // The first reduction may overflow by 1 bit, so we may need to
24     // repeat.  mod == M is not possible; using > allows the faster
25     // sign-bit-based test.
26     if (seed_ > M) {
27       seed_ -= M;
28     }
29     return seed_;
30   }
31   // Returns a uniformly distributed value in the range [0..n-1]
32   // REQUIRES: n > 0
33   uint32_t Uniform(int n) { return Next() % n; }
34 
35   // Randomly returns true ~"1/n" of the time, and false otherwise.
36   // REQUIRES: n > 0
37   bool OneIn(int n) { return (Next() % n) == 0; }
38 
39   // Skewed: pick "base" uniformly from range [0,max_log] and then
40   // return "base" random bits.  The effect is to pick a number in the
41   // range [0,2^max_log-1] with exponential bias towards smaller numbers.
42   uint32_t Skewed(int max_log) {
43     return Uniform(1 << Uniform(max_log + 1));
44   }
45 };