首页 > 其它语言 > 随机数的生成:均匀分布、正态、泊松 、瑞利

随机数的生成:均匀分布、正态、泊松 、瑞利

均匀分布:线性同余法

正态分布:sum-of-12 method

其他分布:逆变换法

  1. /*****************************************   
  2.   
  3. @filename:demo.c   
  4. @datetime:2015.10.18   
  5. @author:HJS    
  6. *****************************************/  
  7. #include <stdio.h>  
  8. #include <stdlib.h>  
  9. #include <math.h>  
  10. /**********************************************************************************************/  
  11. void menu(void);  
  12. double *Uniform_Distribution(unsigned int length, unsigned int num);  
  13. void Demo_Gaussian(void);  
  14. double *Gaussian_Distribution(double miu, double sigma, int length);  
  15. void Demo_Rayleigh(void);  
  16. double *Rayleigh_Distribution(double sigma, int length);  
  17. void Demo_Poisson(void);  
  18. int *Poisson_Distribution(double lamda,unsigned int length);  
  19. /**********************************************************************************************/  
  20. int main()  
  21. {  
  22.     menu();  
  23.     return 0;  
  24. }  
  25. /**********************************************************************************************/  
  26. void menu(void)  
  27. {  
  28.     int num = 0, flag = 0;  
  29.     while(!flag)  
  30.     {  
  31.         printf("---------random variates---------\n");  
  32.         printf("1.gaussian distribution\n2.rayleigh distribution\n3.poisson distribution\n4.exit\n");  
  33.         printf("---------------------------------\nyour choice<1,2,3,4>:");  
  34.         scanf("%d", &num);  
  35.         switch(num)  
  36.         {  
  37.             case 1: Demo_Gaussian();break;  
  38.             case 2: Demo_Rayleigh();break;  
  39.             case 3: Demo_Poisson(); break;  
  40.             case 4: flag = 1;       break;  
  41.             default:                break;  
  42.         }  
  43.         printf("Save success,press any key to continue.\n");  
  44.         getchar();getchar();  
  45.         fflush(stdin);  
  46.         system("cls");  
  47.     }  
  48. }  
  49. /**********************************************************************************************/  
  50. //uniform  
  51. double *Uniform_Distribution(unsigned int length, unsigned int num)  
  52. {  
  53.     unsigned int i = 0;  
  54.     unsigned int xn = (unsigned int)pow(2, 31);  
  55.     unsigned int lamda = (unsigned int)pow(7, 5);  
  56.     unsigned int base = (unsigned int)pow(2, 31) - 1;  
  57.     double *uniform = (double *)malloc(length * sizeof(double));  
  58.     for (i = 0; i < num; i++)  
  59.     {  
  60.         xn = (lamda * xn) % base;  
  61.     }  
  62.     for (i = 0; i < length; i++)  
  63.     {  
  64.         xn = (lamda * xn) % base;  
  65.         uniform[i] = (double)xn / (double)base;  
  66.     }  
  67.     return uniform;  
  68. }  
  69. /**********************************************************************************************/  
  70. /**********************************************************************************************/  
  71. //demo gaussian  
  72. void Demo_Gaussian(void)  
  73. {  
  74.     int i = 0, length = 0;  
  75.     double miu = 0, sigma = 1.0, *gaussian;  
  76.     char filename[50];  
  77.     FILE *fp;  
  78.     printf("length=");  scanf("%d", &length);   //length  
  79.     printf("miu=");     scanf("%lf", &miu);     //miu  
  80.     printf("sigma=");   scanf("%lf", &sigma);   //sigma  
  81.     sprintf(filename, "Gaussian_%d_%d_%d.txt", (int)(miu * 100), (int)(sigma * 100), length);  
  82.     gaussian = Gaussian_Distribution(miu, sigma, length);  
  83.     fp = fopen(filename,"w");   
  84.     for (i = 0; i < length; i++)  
  85.     {  
  86.         fprintf(fp, "%lf\n", gaussian[i]);//fscanf(fp, "%lf", &gaussian[i]);//read data  
  87.     }  
  88.     fclose(fp);  
  89. }  
  90. /*********************************************/  
  91. //Sum-of-12 Method  
  92. double *Gaussian_Distribution_Standard(int length)  
  93. {  
  94.     int i = 0, j = 0;  
  95.     double *gaussian = (double *)malloc(length * sizeof(double));  
  96.     double *(uniform[12]);  
  97.     for (i = 0; i < length; i++)  
  98.     {  
  99.         uniform[i] = Uniform_Distribution(length, (i + 1) * length);  
  100.     }  
  101.     for (j = 0; j < length; j++)  
  102.     {  
  103.         for (i = 0; i < 12; i++)  
  104.         {  
  105.             gaussian[j] = gaussian[j] + uniform[i][j];  
  106.         }  
  107.         gaussian[j] = gaussian[j] - 6.0;  
  108.     }  
  109.     return gaussian;  
  110. }  
  111. //N(miu,sigma)  
  112. double *Gaussian_Distribution(double miu, double sigma, int length)  
  113. {  
  114.     int i = 0;  
  115.     double *gaussian_standard = Gaussian_Distribution_Standard(length);  
  116.     double *gaussian = (double *)malloc(length * sizeof(double));  
  117.     for (i = 0; i < length; i++)  
  118.     {  
  119.         gaussian[i] = gaussian_standard[i] * sqrt(sigma) + miu;  
  120.     }  
  121.     return gaussian;  
  122. }  
  123. /**********************************************************************************************/  
  124. /**********************************************************************************************/  
  125. void Demo_Rayleigh(void)  
  126. {  
  127.     int i = 0, length = 0;  
  128.     char filename[50];//filename  
  129.     double sigma = 1.0, *rayleigh;  
  130.     FILE *fp;  
  131.     printf("length=");      scanf("%d", &length);  
  132.     printf("sigma=");       scanf("%lf", &sigma);  
  133.     sprintf(filename, "Rayleigh_%d_%d.txt", (int)(sigma * 100), length);  
  134.     rayleigh = Rayleigh_Distribution(sigma, length);  
  135.     fp = fopen(filename,"w");   
  136.     for (i = 0; i < length; i++)  
  137.     {  
  138.         fprintf(fp, "%lf\n", rayleigh[i]);  
  139.     }  
  140.     fclose(fp);  
  141.   
  142. }  
  143. //rayleigh  
  144. double *Rayleigh_Distribution(double sigma, int length)  
  145. {  
  146.     int i = 0;  
  147.     double *uniform = Uniform_Distribution(length, length);  
  148.     double *rayleigh = (double *)malloc(length * sizeof(double));  
  149.     for (i = 0; i < length; i++)  
  150.     {  
  151.         rayleigh[i] = sqrt(-log(pow(uniform[i], 2))) * sigma;  
  152.     }  
  153.     return rayleigh;  
  154. }  
  155. /**********************************************************************************************/  
  156. /**********************************************************************************************/  
  157. //demo poisson  
  158. void Demo_Poisson(void)  
  159. {  
  160.     int i = 0, length = 0;  
  161.     char filename[50];  
  162.     double lamda = 0;  
  163.     int *poisson;  
  164.     FILE *fp;  
  165.     printf("length=");  scanf("%d", &length);  
  166.     printf("lamda=");   scanf("%lf", &lamda);  
  167.     sprintf(filename, "Poisson_%d_%d.txt", (int)(lamda * 100), length);  
  168.     poisson = Poisson_Distribution(lamda, length);  
  169.     fp = fopen(filename,"w");   
  170.     for (i = 0; i < length; i++)  
  171.     {  
  172.         fprintf(fp, "%d\n", poisson[i]);  
  173.     }  
  174.     fclose(fp);  
  175. }  
  176. //poisson  
  177. int *Poisson_Distribution(double lamda,unsigned int length)  
  178. {  
  179.     unsigned int i = 0, k = 0;  
  180.     int *poisson = (int *)malloc(length * sizeof(int));  
  181.     double ans = 1.0, temp = exp(-lamda);  
  182.     srand((unsigned int)NULL);  
  183.     for (i = 0; i < length; i++)  
  184.     {  
  185.         while(ans >= temp)  
  186.         {  
  187.             k++;  
  188.             ans = ans * rand() / 32767.0;  
  189.         }  
  190.         poisson[i] = k - 1;  
  191.         ans = 1.0;  
  192.         k = 0;  
  193.     }  
  194.     return poisson;  
  195. }  

本文固定链接: http://www.devba.com/index.php/archives/6429.html | 开发吧

报歉!评论已关闭.