21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › GD32的随机数生成（可服从任意分布函数）正态、柯... ...
返回列表 发新帖我要提问

GD32的随机数生成（可服从任意分布函数）正态、柯...

[复制链接]
6485|0
 楼主| zeshoufx 发表于 2021-8-23 18:41 | 显示全部楼层 |阅读模式
随机数, 函数, BLE, se, double, AC
#申请原创#@21小跑堂
一、实际项目中，经常需要产生一些符合某某分布的随机数，如（服从均匀分布的随机数、服从柯西分布的随机数等）；


二、GD32F450本身自带的真随机数发生器是通过连续模拟噪声生成一个 32 位的随机数值，但无法确定服从什么分布；另一方面不带真随机数发生器的单片机也有很多。


三、通过ADC采集随机噪声作为随机数同自带的真随机数发生器一样，无法确定噪声服从是满分布；综上所述，需要产生服从某某分布的随机数需要从算法进行解决。关键对带不带真随机数发生器的单片机都可以适用

四、服从均匀分布随机数
338446123738fba074.png
复制
  1. //均匀分布
    

  2. double uniform(double a,double b,long int * seed)
    

  3. {
    

  4.         double t;
    

  5.         * seed=2045*(*seed)+1;
    

  6.         * seed=*seed-(*seed/1048576)*1048576;
    

  7.         t=(*seed)/1048576.0;
    

  8.         t=a+(b-a)*t;
    

  9.         return t;
    

  10. }
93705612373daaeeb3.png

五、服从高斯分布（正态分布）的随机数
724306123744c02f90.png
复制
  1. //高斯（正态）分布
    

  2. double guass(double mean,double sigma,long int *seed)
    

  3. {
    

  4.         int i;
    

  5.         double x,y;
    


  6. 

  7.         for (x=0,i=0;i<12;i++)
    

  8.         {
    

  9.                 x+=uniform(0.0,1.0,seed);
    

  10.         }
    

  11.         x-=6.0;
    

  12.         y=mean+x*sigma;
    

  13.         return y;
    

  14. }
163986123746832c13.png

六、服从指数分布的随机数生成
94906612374d7496cd.png
复制
  1. //指数分布
    

  2. double exponent(double beta,long int *seed)
    

  3. {
    

  4.         double u,x;
    

  5.         u=uniform(0.0,1.0,seed);
    

  6.         x=-beta*log(u);
    

  7.         return x;
    

  8. }
8452612374f3002cb.png


七、服从拉普拉斯分布的随机数
6801761237547cb3ea.png
复制
  1. //拉普拉斯分布
    

  2. double laplace(double beta,long int *seed)
    

  3. {
    

  4.         double u1,u2,x;
    


  5. 

  6.         u1=uniform(0.0,1.0,seed);
    

  7.         u2=uniform(0.0,1.0,seed);
    


  8. 

  9.         if(u1<0.5)
    

  10.         {
    

  11.                 x=-beta*log(1.0-u2);
    

  12.         }
    

  13.         else
    

  14.         {
    

  15.                 x=beta*log(u2);
    

  16.         }
    

  17.         return x;
    

  18. }
26327612375666a541.png

八、服从瑞利分布的随机数生成

43834612375b649b89.png
复制
  1. //瑞利分布
    

  2. double rayleigh(double sigma,long int *seed)
    

  3. {
    

  4.         double u,x;
    

  5.         u=uniform(0.0,1.0,seed);
    

  6.         x=-2.0*log(u);
    

  7.         x=sigma*sqrt(x);
    


  8. 

  9.         return x;
    

  10. }
36659612375d305012.png

九、服从对数正态分布的随机数生成
51036123761cac3e8.png
复制
  1. //对数-正态分布
    

  2. double logform(double u,double sigma,long int *seed)
    

  3. {
    

  4.         double x,y;
    

  5.         y=guass(u,sigma,seed);
    


  6. 

  7.         x=exp(y);
    

  8.         return x;
    

  9. }
656416123762d99f7a.png

十、服从柯西分布的随机数生成
464506123767957236.png
复制
  1. //柯西分布
    

  2. double cauchy(double a,double b,long int *seed)
    

  3. {
    

  4.         double u,x;
    

  5.         u=uniform(0.0,1.0,seed);
    

  6.         x=a-b/tan(3.1492653*u);
    


  7. 

  8.         return x;
    

  9. }
87031612376884eec7.png

十一、服从韦伯分布的随机数生成
10882612376ca800da.png
复制
  1. //韦伯分布
    

  2. double weibull(double a,double b,long int *seed)
    

  3. {
    

  4.         double u,x;
    


  5. 

  6.         u=uniform(0.0,1.0,seed);
    

  7.         u=-log(u);
    

  8.         x=b*pow(u,1.0/a);
    


  9. 

  10.         return x;
    

  11. }
46462612376de476e2.png

十二、服从埃尔朗分布的随机数生成
684836123771db4a94.png
复制
  1. //埃尔朗分布
    

  2. double erlang(int m,double beta,long int *seed)
    

  3. {
    

  4.         int i;
    

  5.         double u,x;
    


  6. 

  7.         for(u=1.0,i=1;i<m;i++)
    

  8.         {
    

  9.                 u*=uniform(0.0,1.0,seed);
    

  10.         }
    

  11.         x=-beta*log(u);
    


  12. 

  13.         return x;
    


  14. 

  15. }
320956123772e61053.png

十三、服从伯努利分布的随机数生成
6740612377770c65f.png
复制
  1. //伯努利分布
    

  2. int bn(double p,long int *seed)
    

  3. {
    

  4.         int x;
    

  5.         double u;
    

  6.         u=uniform(0.0,1.0,seed);
    


  7. 

  8.         x=(u<p)?1:0;
    

  9.         return x;
    

  10. }
121316123778af0532.png

十四、服从伯努利-高斯分布的随机数生成
3572612377d11206c.png
复制
  1. //伯努利-高斯分布
    

  2. double bn_gauss(double p,double mean,double sigma,long int *seed)
    

  3. {
    

  4.         double u,x;
    

  5.         u=uniform(0.0,1.0,seed);
    


  6. 

  7.         if(u<p)
    

  8.         {
    

  9.                 x=guass(mean,sigma,seed);
    

  10.         }
    

  11.         else
    

  12.         {
    

  13.                 x=0.0;
    

  14.         }
    

  15.         return x;
    

  16. }
5507612377e527afd.png

十五、服从二项式分布的随机数生成
72968612378416baa4.png
复制
  1. //二项式分布
    

  2. int bin_(int n,double p,long int *seed)
    

  3. {
    

  4.         int i;
    

  5.         int x;
    

  6.         for(x=0,i=0;i<n;i++)
    

  7.         {
    

  8.                 x+=bn(p,seed);
    

  9.         }
    


  10. 

  11.         return x;
    

  12. }
52669612378513c23b.png

十六、服从泊松分布的随机数生成
5252961237890a16bc.png
复制
  1. //泊松分布
    

  2. int poisson(double lamuda,long int *seed)
    

  3. {
    

  4.         int i=0,x;
    

  5.         double a,b=1.0,u;
    


  6. 

  7.         a=exp(-lamuda);
    

  8.         do
    

  9.         {
    

  10.                 u=uniform(0.0,1.0,seed);
    

  11.                 b*=u;
    

  12.                 i++;
    

  13.         }while(b>=a);
    

  14.         x=i-1;
    


  15. 

  16.         return x;
    

  17. }
351706123789e242c5.png

十七、测试平台：GD32F450ZiT6


十八、测试主函数
复制
  1. /*!
    

  2.     \file    main.c
    

  3.     \brief   design by 张恩寿 
    

  4.     
    

  5.     \version 2021-08-15, V1.0.0, SDK for keria
    

  6.     
    

  7. */
    


  8. 

  9. /*
    

  10.     昆明电器科学研究所.
    


  11. 

  12. */
    


  13. 

  14. #include "usart.h"
    

  15. #include "systick.h"
    

  16. #include "led.h"
    

  17. #include "key.h"
    

  18. #include "eeprom.h"
    

  19. #include "rng.h"
    


  20. 


  21. 

  22. u16 mem_size[2]={0};
    

  23. u32 uid[3]={0};
    


  24. 

  25. static void rng_uniform_test(void)
    

  26. {
    

  27.         double a,b,x;
    

  28.         int i,j;
    

  29.         long int s;
    

  30.         a=0.0;
    

  31.         b=1.0;
    

  32.         s=13579;
    

  33.         for(i=0;i<10;i++)
    

  34.         {
    

  35.                 for(j=0;j<5;j++)
    

  36.                 {
    

  37.                         x=uniform(a,b,&s); 
    

  38.                         printf("%13.7f",x);
    

  39.                 }
    

  40.                 printf("\r\n");
    

  41.         }
    

  42. }
    


  43. 

  44. static void rng_guass_test(void)
    

  45. {
    

  46.         int i,j;
    

  47.         long int s=13579;
    

  48.         double mean=0.0;
    

  49.         double sigma=1.0;
    

  50.         double x;
    


  51. 

  52.         for(i=0;i<10;i++)
    

  53.         {
    

  54.                 for(j=0;j<5;j++)
    

  55.                 {
    

  56.                         x=guass(mean,sigma,&s);
    

  57.                         printf("%13.7lf",x);
    

  58.                 }
    

  59.                 printf("\r\n");
    

  60.         }
    

  61. }
    


  62. 

  63. static void rng_exponent_test(void)
    

  64. {
    

  65.         int i,j;
    

  66.         long int s=13579;
    

  67.         double x;
    

  68.         double beta=2.0;
    


  69. 

  70.         for(i=0;i<10;i++)
    

  71.         {
    

  72.                 for(j=0;j<5;j++)
    

  73.                 {
    

  74.                         x=exponent(beta,&s);
    

  75.                         printf("%13.7lf",x);
    

  76.                 }
    

  77.                 printf("\r\n");
    

  78.         }
    

  79. }
    


  80. 

  81. static void rng_laplace_test(void)
    

  82. {
    

  83.         int i,j;
    

  84.         long int s=13579;
    

  85.         double x,beta=1.5;
    


  86. 

  87.         for(i=0;i<10;i++)
    

  88.         {
    

  89.                 for(j=0;j<5;j++)
    

  90.                 {
    

  91.                         x=laplace(beta,&s);
    

  92.                         printf("%13.7lf",x);
    

  93.                 }
    

  94.                 printf("\r\n");
    

  95.         }
    

  96. }
    


  97. 

  98. static void rng_rayleigh_test(void)
    

  99. {
    

  100.         int i,j;
    

  101.         long int s=13579;
    

  102.         double x,sigma=1.0;
    


  103. 

  104.         for(i=0;i<10;i++)
    

  105.         {
    

  106.                 for(j=0;j<5;j++)
    

  107.                 {
    

  108.                         x=rayleigh(sigma,&s);
    

  109.                         printf("%13.7lf",x);
    

  110.                 }
    

  111.                 printf("\r\n");
    

  112.         }
    

  113. }
    


  114. 

  115. static void rng_logform_test(void)
    

  116. {
    

  117.         int i,j;
    

  118.         long int s=13579;
    

  119.         double x,u=0.0,sigma=0.5;
    


  120. 

  121.         for(i=0;i<10;i++)
    

  122.         {
    

  123.                 for(j=0;j<5;j++)
    

  124.                 {
    

  125.                         x=logform(u,sigma,&s);
    

  126.                         printf("%13.7lf",x);
    

  127.                 }
    

  128.                 printf("\r\n");
    

  129.         }
    

  130. }
    


  131. 


  132. 

  133. static void rng_cauchy_test(void)
    

  134. {
    

  135.         int i,j;
    

  136.         long int s=13579;
    

  137.         double x,a=1.0,b=1.0;
    


  138. 

  139.         for(i=0;i<10;i++)
    

  140.         {
    

  141.                 for(j=0;j<5;j++)
    

  142.                 {
    

  143.                         x=cauchy(a,b,&s);
    

  144.                         printf("%13.7lf",x);
    

  145.                 }
    

  146.                 printf("\r\n");
    

  147.         }
    

  148. }
    


  149. 

  150. static void rng_weibull_test(void)
    

  151. {
    

  152.         int i,j;
    

  153.         long int s=13579;
    

  154.         double x,a=2.0,b=1.0;
    

  155.         for(i=0;i<10;i++)
    

  156.         {
    

  157.                 for (j=0;j<5;j++)
    

  158.                 {
    

  159.                         x=weibull(a,b,&s);
    

  160.                         printf("%13.7lf",x);
    

  161.                 }
    

  162.                 printf("\r\n");
    

  163.         }
    

  164. }
    


  165. 

  166. static void rng_erlang_test(void)
    

  167. {
    

  168.         int i,j,m=3;
    

  169.         double x,beta=1.0;
    

  170.         long int s=13579;
    


  171. 

  172.         for(i=0;i<10;i++)
    

  173.         {
    

  174.                 for(j=0;j<5;j++)
    

  175.                 {
    

  176.                         x=erlang(m,beta,&s);
    

  177.                         printf("%13.7lf",x);
    

  178.                 }
    

  179.                 printf("\r\n");
    

  180.         }
    

  181. }
    


  182. 

  183. static void rng_bn_test(void)
    

  184. {
    

  185.         int i,j,x;
    

  186.         long int s=13579;
    

  187.         double p=0.7;
    

  188.         for (i=0;i<10;i++)
    

  189.         {
    

  190.                 for(j=0;j<5;j++)
    

  191.                 {
    

  192.                         x=bn(p,&s);
    

  193.                         printf("%11d",x);
    

  194.                 }
    

  195.                 printf("\r\n");
    

  196.         }
    

  197. }
    


  198. 

  199. static void rng_bn_gauss_test(void)
    

  200. {
    

  201.         int i,j;
    

  202.         long int s=13579;
    

  203.         double x,p=0.4,mean=0.0,sigma=1;
    


  204. 

  205.         for(i=0;i<10;i++)
    

  206.         {
    

  207.                 for(j=0;j<5;j++)
    

  208.                 {
    

  209.                         x=bn_gauss(p,mean,sigma,&s);
    

  210.                         printf("%13.7lf",x);
    

  211.                 }
    

  212.                 printf("\r\n");
    

  213.         }
    

  214. }
    


  215. 

  216. static void rng_bin__test(void)
    

  217. {
    

  218.         int i,j,n=5,x;
    

  219.         long int s=13579;
    

  220.         double p=0.7;
    


  221. 

  222.         for(i=0;i<10;i++)
    

  223.         {
    

  224.                 for(j=0;j<5;j++)
    

  225.                 {
    

  226.                         x=bin_(n,p,&s);
    

  227.                         printf("%11d",x);
    

  228.                 }
    

  229.                 printf("\r\n");
    

  230.         }
    

  231. }
    


  232. 

  233. static void rng_poisson_test(void)
    

  234. {
    

  235.         int i,j,x;
    

  236.         long int s=13579;
    

  237.         double n=4.0;
    


  238. 

  239.         for(i=0;i<10;i++)
    

  240.         {
    

  241.                 for(j=0;j<5;j++)
    

  242.                 {
    

  243.                         x=poisson(n,&s);
    

  244.                         printf("%11d",x);
    

  245.                 }
    

  246.                 printf("\r\n");
    

  247.         }
    

  248. }
    


  249. 

  250. int main(void)
    

  251. {
    

  252.         nvic_priority_group_set(NVIC_PRIGROUP_PRE2_SUB2);
    

  253.         systick_set(200);
    

  254.     
    

  255.         eeprom_io_set();
    

  256.         
    

  257.         usart_config(115200);
    

  258.         mem_size[0]=mem_size_get(mem_flash);
    

  259.         mem_size[1]=mem_size_get(mem_sram);
    

  260.         get_cpu_uid(uid);
    

  261.         
    

  262.         led_set();
    

  263.         key_set();
    

  264.         
    

  265.         
    

  266.         printf("welcome to use platform of GD32F450\r\n");
    

  267.         printf("cpu flash size:%d,sram size:%d\r\n",mem_size[0],mem_size[1]);
    

  268.         printf("cpu uid code:0X%X%X%X\r\n",uid[0],uid[1],uid[2]);
    

  269.         
    

  270.         
    

  271.         eeprom_write_byte(0,241);
    

  272.         eeprom_wait_standby_state();
    

  273.         printf("%d\r\n",eeprom_read_byte(0));
    

  274.         
    

  275.         eeprom_write_u16(1,565);
    

  276.         printf("%d\r\n",eeprom_read_u16(1));
    

  277.         
    

  278.         eeprom_write_int(3,-3000);
    

  279.         printf("%d\r\n",eeprom_read_int(3));
    

  280.         
    

  281.         eeprom_write_u32(7,3000);
    

  282.         printf("%d\r\n",eeprom_read_u32(7));
    

  283.         
    

  284.         eeprom_write_float(11,5.214);
    

  285.         printf("%f\r\n",eeprom_read_float(11));
    

  286.         
    

  287.         printf("\r\n");
    

  288.         printf("服从均匀分布随机数测试：\r\n");
    

  289.         rng_uniform_test();
    

  290.         
    

  291.         printf("\r\n");
    

  292.         printf("服从正态分布随机数测试：\r\n");
    

  293.         rng_guass_test();
    

  294.         
    

  295.         printf("\r\n");
    

  296.         printf("服从指数分布随机数测试：\r\n");
    

  297.         rng_exponent_test();
    

  298.         
    

  299.         printf("\r\n");
    

  300.         printf("服从拉普拉斯分布随机数测试：\r\n");
    

  301.         rng_laplace_test();
    

  302.         
    

  303.         printf("\r\n");
    

  304.         printf("服从瑞利分布随机数测试：\r\n");
    

  305.         rng_rayleigh_test();
    

  306.         
    

  307.         printf("\r\n");
    

  308.         printf("服从对数-正态分布随机数测试：\r\n");
    

  309.         rng_logform_test();
    

  310.         
    

  311.         printf("\r\n");
    

  312.         printf("服从柯西分布随机数测试：\r\n");
    

  313.         rng_cauchy_test();
    

  314.         
    

  315.         printf("\r\n");
    

  316.         printf("服从韦伯分布随机数测试：\r\n");
    

  317.         rng_weibull_test();
    

  318.         
    

  319.         printf("\r\n");
    

  320.         printf("服从埃尔朗分布随机数测试：\r\n");
    

  321.         rng_erlang_test();
    

  322.         
    

  323.         printf("\r\n");
    

  324.         printf("服从伯努利分布随机数测试：\r\n");
    

  325.         rng_bn_test();
    

  326.         
    

  327.         printf("\r\n");
    

  328.         printf("服从伯努利-高斯分布随机数测试：\r\n");
    

  329.         rng_bn_gauss_test();
    

  330.         
    

  331.         printf("\r\n");
    

  332.         printf("服从二项式分布随机数测试：\r\n");
    

  333.         rng_bin__test();
    

  334.         
    

  335.         printf("\r\n");
    

  336.         printf("服从泊松分布随机数测试：\r\n");
    

  337.         rng_poisson_test();
    

  338.         
    

  339.         
    

  340.     while (1)
    

  341.         {
    

  342.                 
    

  343.                 led=!led;
    

  344.                 delay_ms(1000);
    

  345.     }
    

  346. }


十九、工程文件

测试平台

测试平台
回复

收藏 举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

zeshoufx

67

主题

1991

帖子

15

粉丝
快速回复 在线客服 返回列表 返回顶部