MersenneTwister-Android（java）和C（Arduino）中相同的伪随机数

我必须使用一个伪随机数生成器在不同的平台上使用相同的种子获得相同的数

我试着在Android（java）和Arduino（c）中的random类中设置“seed”，它们给我的是不同的数字和相同的种子，我需要的是两个系统中相同的数字和相同的种子

所以，我尝试了“Mersenne Twister”在两个系统中获得相同的伪随机数

这是我在Arduino库中的代码：

/* 
   A C-program for MT19937, with initialization improved 2002/1/26.
   Coded by Takuji Nishimura and Makoto Matsumoto.

   Before using, initialize the state by using init_genrand(seed)  
   or init_by_array(init_key, key_length).

   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
   All rights reserved.                          

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions
   are met:

     1. Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.

     2. Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.

     3. The names of its contributors may not be used to endorse or promote 
        products derived from this software without specific prior written 
        permission.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


   Any feedback is very welcome.
   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
*/

//#include <stdio.h>

/* Period parameters */  
#define N 624
#define M 397
#define MATRIX_A 0x9908b0dfUL   /* constant vector a */
#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
#define LOWER_MASK 0x7fffffffUL /* least significant r bits */

static unsigned int mt[N]; /* the array for the state vector  */
static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */

/* initializes mt[N] with a seed */
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); 
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
        /* In the previous versions, MSBs of the seed affect   */
        /* only MSBs of the array mt[].                        */
        /* 2002/01/09 modified by Makoto Matsumoto             */
        mt[mti] &= 0xffffffffUL;
        /* for >32 bit machines */
    }
}

/* initialize by an array with array-length */
/* init_key is the array for initializing keys */
/* key_length is its length */
/* slight change for C++, 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; /* non linear */
        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
        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; /* non linear */
        mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
        i++;
        if (i>=N) { mt[0] = mt[N-1]; i=1; }
    }

    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
}

/* generates a random number on [0,0xffffffff]-interval */
unsigned long genrand_int32(void)
{
    unsigned long y;
    static unsigned long mag01[2]={0x0UL, MATRIX_A};
    /* mag01[x] = x * MATRIX_A  for x=0,1 */

    if (mti >= N) { /* generate N words at one time */
        int kk;

        if (mti == N+1)   /* if init_genrand() has not been called, */
            init_genrand(5489UL); /* a default initial seed is used */

        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;
}

/* generates a random number on [0,0x7fffffff]-interval */
long genrand_int31(void)
{
    return (long)(genrand_int32()>>1);
}

unsigned long generate_long(unsigned long n)
{
    unsigned long bits, val;
    do {
      bits = (genrand_int31() << 1);
      val = bits % n;
    } 
    while(bits - val + (n-1) < 0);
    return val;
}

/* generates a random number on [0,1]-real-interval */
double genrand_real1(void)
{
    return genrand_int32()*(1.0/4294967295.0); 
    /* divided by 2^32-1 */ 
}

/* generates a random number on [0,1)-real-interval */
double genrand_real2(void)
{
    return genrand_int32()*(1.0/4294967296.0); 
    /* divided by 2^32 */
}

/* generates a random number on (0,1)-real-interval */
double genrand_real3(void)
{
    return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0); 
    /* divided by 2^32 */
}

/* generates a random number on [0,1) with 53-bit resolution*/
double genrand_res53(void) 
{ 
    unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6; 
    return(a*67108864.0+b)*(1.0/9007199254740992.0); 
} 
/* These real versions are due to Isaku Wada, 2002/01/09 added */

/*
MT19937的C程序，初始化在2002年1月26日改进。
代码由Takuji Nishimura和Makoto Matsumoto编写。
在使用之前，使用init_genrand（种子）初始化状态
或按数组初始化（初始化密钥，密钥长度）。
版权所有（C）1997-2002，松本Makoto Matsumoto和西村Takuji Nishimura，
版权所有。
以源代码和二进制形式重新分发和使用，带或不带
如果满足以下条件，则允许进行修改
满足以下条件：
1.源代码的重新分发必须保留上述版权
请注意，此条件列表和以下免责声明。
2.以二进制形式重新分发必须复制上述版权
请注意，此条件列表和中的以下免责声明
随分发提供的文件和/或其他材料。
3.其出资人的姓名不得用于背书或宣传
未经事先书面许可，从本软件衍生的产品
许可。
本软件由版权所有者和贡献者提供
“原样”和任何明示或暗示的保证，包括但不限于
仅限于对适销性和适用性的默示保证
不承认有特定目的。在任何情况下，版权所有人或
出资人对任何直接、间接、附带、特殊、，
惩戒性或间接损害（包括但不限于，
替代货物或服务的采购；使用、数据或服务的损失
利润；或业务中断），无论是何种原因造成的
责任，无论是合同责任、严格责任还是侵权责任（包括
因使用本文件而产生的任何疏忽或其他原因）
软件，即使已告知此类损坏的可能性。
欢迎任何反馈。
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
电子邮件：m-mat@math.sci.hiroshima-u.ac.jp（删除空格）
*/
//#包括
/*周期参数*/
#定义N 624
#定义M 397
#定义矩阵A 0x9908b0dfUL/*常量向量A*/
#定义上_掩码0x80000000UL/*最高有效w-r位*/
#定义低_掩码0x7fffffffUL/*最低有效r位*/
静态无符号整数mt[N]；/*状态向量的数组*/
静态整数mti=N+1；/*mti==N+1表示mt[N]未初始化*/
/*用种子初始化mt[N]*/
void init_genrand（无符号长s）
{
mt[0]=s&0xffffffffUL；
对于（mti=1；mti>30））+mti）；
/*参见Knuth TAOCP第2卷第3版第106页了解乘数*/
/*在以前的版本中，种子的MSB会影响*/
/*仅阵列mt[]的MSB*/
/*2002/01/09由松本Makoto Matsumoto修改*/
mt[mti]&=0xffffffffUL；
/*对于>32位机器*/
}
}
/*由具有数组长度的数组初始化*/
/*init_key是用于初始化密钥的数组*/
/*键的长度是它的长度*/
/*轻微变化为C++，2004/2／26 */
void init_by_数组（无符号长init_键[]，int键长度）
{
int i，j，k；
init_genrand（19650218UL）；
i=1；j=0；
k=（N>键长？N：键长）；
对于（；k；k--）{
mt[i]=（mt[i]^（（mt[i-1]^（mt[i-1]>>30））*1664525UL）
+初始键[j]+j；/*非线性*/
mt[i]&=0xffffffffUL；/*用于字号>32台机器*/
i++；j++；
如果（i>=N）{mt[0]=mt[N-1]；i=1；}
如果（j>=键长）j=0；
}
对于（k=N-1；k；k--）{
mt[i]=（mt[i]^（（mt[i-1]^（mt[i-1]>>30））*1566083941UL）
-i；/*非线性*/
mt[i]&=0xffffffffUL；/*用于字号>32台机器*/
i++；
如果（i>=N）{mt[0]=mt[N-1]；i=1；}
}
mt[0]=0x80000000UL；/*MSB为1；确保初始数组不为零*/
}
/*在[0,0xffffffff]-间隔上生成一个随机数*/
无符号长genrand_int32（无效）
{
无符号长y；
静态无符号长mag01[2]={0x0UL，矩阵_A}；
/*对于x=0,1，mag01[x]=x*矩阵_A*/
如果（mti>=N）{/*一次生成N个字*/
int kk；
如果（mti==N+1）/*如果未调用init_genrand（）*/
init_genrand（5489UL）；/*使用默认初始种子*/
对于（kk=0；kk>1）^mag01[y&0x1UL]；
}
对于（；kk>1）^mag01[y&0x1UL]；
}
y=（mt[N-1]和上|掩码）|（mt[0]和下|掩码）；
mt[N-1]=mt[M-1]^（y>>1）^mag01[y&0x1UL]；
mti=0；
}
y=mt[mti++]；
/*回火*/
y^=（y>>11）；
y^=（y 18）；
返回y；
}
/*在[0,0x7fffffff]-间隔上生成一个随机数*/
long genrand_int31（无效）
{
返回（长）（genrand_int32（）>>1）；
}
无符号长生成_长（无符号长n）
{
无符号长位，val；
做{
位=（genrand_int31（）>5，b=genrand_int32（）>>6；
返回（a*67108864.0+b）*（1.0/9007199254740992.0）；
} 
/*这些真实版本是由于伊萨库和田，2002/01/09补充*/

这是我用java编写的Mersenne Twister： 或 java中的代码或多或少是相等的，至少结果是相同的

你能帮助我为什么不能得到相同的伪随机数吗

提前感谢,，

---

致以最诚挚的问候。

原装Mersenne捻线机无法在具有2KB Ram的MCU上运行

您将mt[]从long改为int break就可以了。

如果您想继续使用Mercenne Twister，请尝试。或者您甚至可以尝试，它的代码要小得多。

您好，