梅森旋转算法

‘壹’ 我想知道各种产生随机数的算法循环周期一次是多长。谢谢大家。

尽管是伪随机数，但也是没有规律的，唯一的规律是n=无穷的情况下，近似服从正态分布。

电脑所产生的随机数规律与程序编程算法有关，可以根据算法让随机数有规律，也可以是无规律，如何找规律都要取决于算法和随机数范围数据，一个比较大较难的随机数是无任何规律的。

称为是随机数，所以也不存在循环问题，而是在一定数据范围内数字随机出现，而不是按排序出现。按排序出现的不能称为随机数。

选取足够大的正整数M和任意自然数n0，a，b，由递推公式：

ni+1=（af（ni）+b）mod M i=0，1，…，M-1

生成的数值序列称为是同余序列。当函数f（n）为线性函数时，即得到线性同余序列：

ni+1=（a*ni+b）mod M i=0，1，…，M-1

以下是线性同余法生成伪随机数的伪代码：

Random（n，m，seed，a，b）

{

r0 = seed；

for （i = 1；i<=n；i++）

ri = （a*ri-1 + b） mod m

}

其中种子参数seed可以任意选择，常常将它设为计算机当前的日期或者时间；m是一个较大数，可以把它取为2w，w是计算机的字长；a可以是0.01w和0.99w之间的任何整数。

应用递推公式产生均匀分布随机数时，式中参数n0，a，b，M的选取十分重要。

(1)梅森旋转算法扩展阅读：

随机数在密码学中非常重要，保密通信中大量运用的会话密钥的生成即需要真随机数的参与。如果一个随机数生成算法是有缺陷的，那么会话密钥可以直接被推算出来。若果真发生这种事故，那么任何加密算法都失去了意义。

密码学中大量利用伪随机数生成器的应用还有流密码。流密码的着名例子是RC4。流密码的原理是利用一个密码学安全的伪随机数生成器根据密钥产生一串密码学安全的伪随机比特列，再将消息与上述随机比特列按位异或运算。

‘贰’ python中，哪个选项是random库中用于生成随机小数的函数

python中，“random()”是random库中用于生成随机小数的函数。

python中用于生成伪随机数的函数库是random，因为是标准库，使用时候只需要import random；random库包含两类函数，常用的共8个：

基本随机函数：seed()，random()

扩展随机函数：randint()，getrandbits()，uniform()，randrange()，choice()，shuffle()

(2)梅森旋转算法扩展阅读：

random库采用梅森旋转算法（Mersennne Twister）生成伪随机数序列，可用于除随机性要求更高的加解密算法外的大多数工程应用。

使用random库的主要目的是生成随机数；该库提供了不同类型的随机数函数，所有函数都是基于最基本的random.random()函数扩展实现。

‘叁’ 我的世界村庄种子是多少

我的世界村庄种子为：37826。

相关介绍：

37826属于超大型村庄种子，里面中会有三个村庄，有铁匠铺、丰富的煤矿等。

一个世界生成后，其种子便已经确定。默认情况下游戏会自动选择种子（使用系统时间）。但玩家也可以手动设置。使用相同的种子可以重复玩相同的世界，种子也可以用于与其他玩家分享世界。种子的设置可以用数字（包括负数）、字符等，非纯数字种子会被自动转换成纯数字。

(3)梅森旋转算法扩展阅读

游戏特点：

在我的世界游戏中，玩家们可以在游戏中自由选择模式(生存、创造、冒险等模式)，在各种模式中体验不一样的有趣玩法,在生存模式中享受打怪、冒险等多种乐趣，在创造模式下享受当创世神的乐趣。

基岩版中的种子，无论是使用数字还是字符串，都有总共4,294,967,296种可能的世界。这个结论对于64位版本的Windows 10版同样成立。这是由于基岩版使用了32位的梅森旋转算法，只接受32位的种子。

‘肆’ 求大神说下关于我的世界种子的原理

通过有限的数字生成无限的世界不难,这串数字经过某个函数公式计算后得的一个无理数(无限不循环的小数),然后再通过这个无理数生成对应的世界也当然是无限的了.比如我输入一个数字3作为种子,对3开平方可以得到一个无理数1.732050.....,然后再以这个无限的数字生成对应的无限的方块,(mc的生成计算是要比这复杂的多的多了).
游戏和现实世界是没法互相并论,至少mc或者说是当今的科技还远远不够,如果考虑因果定律的话,现实宇宙也许有种子类似的东西,不过这个话题相当缥缈,不是几句话就说得清,一辈子可能也弄不明白.

‘伍’ 计算机程序中 Randomize 语句如何执行

你这个涉及到：随机数理论，随机数产生原理和方法，伪随机数发生器的概念。是一个数学里面的大概念。。。

简单地讲，随机数可以分“真”和“伪”随机数两种。 真正的随机数，一般是通过硬件，根据物理现象，比如白噪声等产生；通过算法产生的是伪随机，一般通过一个所谓的种子（数），初始化后，通过不同的演算产生随机数。当然产生的质量好坏，难易程度都是有分别的。

一般电脑语言中如R,Python,Ruby,IDL,Free Pascal,php,Maple,Matlab,GMP以及C++ 11，都是采用的Mersenne Twister即梅森旋转算法。具体实施的时候，是采用梅森旋转的一个变体算法MT19937参数一个32位整数序列，用的种子一般就是电脑上的当前时间，也就是初始化。（pascal里面用Randomize， 然后调用random()产生伪随机数；c里面srand (time(NULL))初始化，然后rand()产生随机数） －－－ 主要考虑的是方便、快捷。 密码学和应用里面都需要用到随机数，根据等级的需要，需要采用更好的随机产生算法。

至于你说的范围， 根据上面提到的“伪”随机算法，产生了的随机数是一个32位，范围是0~2^(32-1)，但不同语言，不同版本在实现的时候，都规定了一个上下，即C中的RAND_MAX （GCC里是31位的0x7FFFFFFF；vc++ 2012里面则是0x7fff）。如果你希望产生一个自己的范围内的随机数[min, max]，那么作一个转换映射，那么你的随机数＝min + rand() / (RAND_MAX / (max - min + 1) + 1);

因此：我们一般提到的随机数，都是“伪”随机数。调用语言的函数库所提供的随机数发生器，都是通过算法产生的，而这些算法都是由数学背景在里面，产生的质量有好有坏，需要根据自己的需要酌情处理。

‘陆’ PHP 中iVBOR是什么函数生成的

在PHP编程中，我们有时候在高并发的时候生成很多个不同的ID，用于标识一些东西。虽然有很多方法，可以实现这一过程，不过PHP还是给我们提供了一个很好的函数，用于生成不同的唯一的ID
PHP中的uniqid()函数
函数定义
uniqid() 函数基于以微秒计的当前时间，生成一个唯一的 ID。
语法
uniqid(prefix,more_entropy)

注释：
prefix可选。为 ID 规定前缀。如果两个脚本恰好在相同的微秒生成 ID，该参数很有用。
more_entropy 可选。规定位于返回值末尾的更多的熵。
举例说明
利用uniqid()生成一个ID
<?php//XXXXX
echo '输出一个唯一的ID标示符：'.uniqid();?>
echo '输出一个唯一的CHAODIQUAN.COM 标示符：'.uniqid();?>
利用for循环与uniqid()函数，连续生成10个不同的ID标识
代码
<?php//XXXXXXfor($i=1;$i<11;$i++){
echo '输出第'.$i.'个标示符：'.uniqid().'<br/>';}?>

对于uniqid()函数补充

如果我们单纯使用 uniqid()
这个方法，不带任何参数的话，这个方法只能保证单个进程，在同一个毫秒内是唯一的。如果使用uniqid("", true)。
带了一个墒值，自身已经有一个随机的方式能保证生成的id的随机性了。但是由于线性同余是比较简单的生成随机数的算法，随机性有可能还不够，所以，网上流传的一种更随机数值的方式是：
uniqid(mt_rand(), true)

其中
mt_rand() 生成随机数就不是使用线性同余生成随机数的方式了，而是使用 Mersenne Twister Random Number
Generator （梅森旋转算法）。换句话说，上面这个 id 由两种随机算法 ＋
时间戳生成。基本上，这个算法在很大程度上能保证唯一性了（如果要问冲突率的话，估计只有数学系学生能研究出来了...）。
上面的这个给出的id会有一个点号，而且长度并不是128bit。如果希望生成uuid，就需要一个hash，不管是md5,sha1 都是可以选择的。所以网上又有一种生成唯一码的方式。
md5(uniqid(mt_rand(), true))
复制
但是，本质上，这两种方式的随机性是相等的。

‘柒’ 梅森旋转算法可以在电脑上运行吗。就是软件运行。不需要梅森旋转算法的硬件。谢谢。

可以，但是模拟器很小，只能使用键盘控制很不方便，建议不要使用，而且不是每个模拟器都能使用的

‘捌’ 梅森旋转素数算法（MT199937）c语言代码

#include<cstdio> /*Periodparameters*/
#define N 624
#define M 397
#define MATRIX_A 0x9908b0dfUL /*constantvectora*/
#define UPPER_MASK 0x80000000UL/*mostsignificantw-rbits*/
#define LOWER_MASK 0x7fffffffUL/*leastsignificantrbits*/

static unsigned long mt[N];/*thearrayforthestatevector*/
static int mti=N+1;/*mti==N+1meansmt[N]isnotinitialized*/ /*initializesmt[N]withaseed*/
void init_genrand(unsigned long s)
{
mt[0]=s & 0xffffffffUL;
for(mti=1;mti<N;mti++)
{
mt[mti]=
(1812433253UL*(mt[mti-1]^(mt[mti-1]>>30))+mti); /*SeeKnuthTAOCPVol2.3rdEd.P.106formultiplier.*//*Inthepreviousversions,MSBsoftheseedaffect*//*onlyMSBsofthearraymt[].*//*2002/01/09modifiedbyMakotoMatsumoto*/
mt[mti]&=0xffffffffUL;/*for>32bitmachines*/
}
} /*initializebyanarraywitharray-length*//*init_*//*key_lengthisitslength*/ /*slightchangeforC++,2004/2/26*/
void init_by_array(unsigned long init_key[],int key_length)
{
int i,j,k; init_genrand(19650218UL);
i=1;j=0;
k=(N>key_length?N:key_length);
for(;k;k--)
{
mt[i]=(mt[i]^((mt[i-1]^(mt[i-1]>>30))*1664525UL))
+init_key[j]+j;/*nonlinear*/
mt[i]&=0xffffffffUL;/*forWORDSIZE>32machines*/
i++;j++; if(i>=N){mt[0]=mt[N-1];i=1;}if(j>=key_length)j=0;
}
for(k=N-1;k;k--)
{ mt[i]=(mt[i]^((mt[i-1]^(mt[i-1]>>30))*1566083941UL)) -i;/*nonlinear*/
mt[i]&=0xffffffffUL;/*forWORDSIZE>32machines*/i++;
if(i>=N){mt[0]=mt[N-1];i=1;} }
mt[0]=0x80000000UL;
/*MSBis1;assuringnon-zeroinitialarray*/ } /*generatesarandomnumberon[0,0xffffffff]-interval*/
unsigned long genrand_int32(void)
{
unsigned long y;
static unsigned long mag01[2]={0x0UL,MATRIX_A};/*mag01[x]=x*MATRIX_Aforx=0,1*/
if(mti>=N){/*generateNwordsatonetime*/ int kk;
if(mti==N+1)/*ifinit_genrand()hasnotbeencalled,*/
init_genrand(5489UL);/*adefaultinitialseedisused*/
for(kk=0;kk<N-M;kk++)
{
y=(mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);mt[kk]=mt[kk+M]^(y>>1)^mag01[y&0x1UL];
} for(;kk<N-1;kk++)
{ y=(mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk]=mt[kk+(M-N)]^(y>>1)^mag01[y&0x1UL];
}
y=(mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
mt[N-1]=mt[M-1]^(y>>1)^mag01[y&0x1UL];mti=0; }
y=mt[mti++]; /*Tempering*/
y^=(y>>11); y^=(y<<7)&0x9d2c5680UL;y^=(y<<15)&0xefc60000UL;y^=(y>>18);
return y;
} /*generatesarandomnumberon[0,0x7fffffff]-interval*/
long genrand_int31(void)
{ return(long)(genrand_int32()>>1); } /*generatesarandomnumberon[0,1]-real-interval*/
double genrand_real1(void)
{ return genrand_int32()*(1.0/4294967295.0); }
double genrand_real2(void)
{ return genrand_int32()*(1.0/4294967296.0);/*dividedby2^32*/ } /*generatesarandomnumberon(0,1)-real-interval*/
double genrand_real3(void)
{ return(((double)genrand_int32())+0.5)*(1.0/4294967296.0);/*dividedby2^32*/ }
/*generatesarandomnumberon[0,1)with53-bitresolution*/
double genrand_res53(void)
{ unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0); } /*,2002/01/09added*/
int main(void){
int i; unsigned long init[4]={0x123,0x234,0x345,0x456},length=4;init_by_array(init,length); printf("1000outputsofgenrand_int32()\n");
for(i=0;i<1000;i++)
{
printf("%10lu",genrand_int32());
if(i%5==4)printf("\n"); }
printf("\n1000outputsofgenrand_real2()\n");
for(i=0;i<1000;i++){ printf("%10.8f",genrand_real2());
if(i%5==4)printf("\n"); }
return 0;
}

‘玖’ 有个梅森旋转素数算法(MT199937)c语言代码相关的问题，希望大神们能给我讲解一下，感激不尽呀。

这个是宏定义，#define
#define GPEBLT_FUNCNAME(basename) (SCODE (GPE::*)(struct GPEBltParms *))&GPE::##basename
在#define中，标准只定义了#和##两种操作。#用来把参数转换成字符串，##则用来连接前后两个参数，把它们变成一个字符串。
#include<stdio.h>
#define paster(n) printf("token"#n"=%d\n",token##n)
int main(int argc,char *argv[])
{
int token9=10;
paster(9);
return 0;
}
输出为:token 9 = 10
详细请看网络：#define

‘拾’ python中的随机数是怎么实现的

PYTHON中的伪随机数发生器用的是梅森旋转算法。
梅森旋转算法（Mersenne twister）是一个伪随机数发生算法。由松本真和西村拓士在1997年开发，基于有限二进制字段上的矩阵线性递归。可以快速产生高质量的伪随机数，修正了古典随机数发生算法的很多缺陷。
梅森旋转算法是R、Python、Ruby、IDL、Free Pascal、PHP、Maple、Matlab、GNU多重精度运算库和GSL的默认伪随机数产生器。从C++11开始，C++也可以使用这种算法。
整个算法主要分为三个阶段：获得基础的梅森旋转链；对于旋转链进行旋转算法；对于旋转算法所得的结果进行处理。
算法实现的过程中，参数的选取取决于梅森素数，故此得名。
梅森素数由梅森数而来。所谓梅森数，是指形如2↑p－1的一类数，其中指数p是素数，常记为Mp 。如果梅森数是素数，就称为梅森素数。
例如4-1=3，8-1=7，16-1=15（不是素数），32-1=31，64-1=63（不是素数）等等。