可植入 JavaScript 随机数生成器

Question

JavaScript Math.random()< /code>函数返回 0 到 1 之间的随机值，根据当前时间自动播种（我相信类似于 Java）。 但是，我认为没有任何方法可以为其设置自己的种子。

如何制作一个随机数生成器，我可以为其提供自己的种子值，以便我可以让它生成可重复的（伪）随机数序列？

Answer 1

如果您不需要播种功能，只需使用 Math.random() 并围绕它构建辅助函数（例如，randRange(start, end)）。

我不确定您使用的是什么 RNG，但最好了解并记录它，以便您了解其特征和局限性。

正如 Starkii 所说，Mersenne Twister 是一个很好的 PRNG，但实现起来并不容易。 如果您想自己尝试实现 LCG - 它非常简单，具有良好的随机性质量（不如 Mersenne Twister），并且您可以使用一些流行的常量。

编辑：考虑这个答案中用于短可种子RNG实现的绝佳选项，包括LCG选项。

function RNG(seed) {
  // LCG using GCC's constants
  this.m = 0x80000000; // 2**31;
  this.a = 1103515245;
  this.c = 12345;

  this.state = seed ? seed : Math.floor(Math.random() * (this.m - 1));
}
RNG.prototype.nextInt = function() {
  this.state = (this.a * this.state + this.c) % this.m;
  return this.state;
}
RNG.prototype.nextFloat = function() {
  // returns in range [0,1]
  return this.nextInt() / (this.m - 1);
}
RNG.prototype.nextRange = function(start, end) {
  // returns in range [start, end): including start, excluding end
  // can't modulu nextInt because of weak randomness in lower bits
  var rangeSize = end - start;
  var randomUnder1 = this.nextInt() / this.m;
  return start + Math.floor(randomUnder1 * rangeSize);
}
RNG.prototype.choice = function(array) {
  return array[this.nextRange(0, array.length)];
}

var rng = new RNG(20);
for (var i = 0; i < 10; i++)
  console.log(rng.nextRange(10, 50));

var digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
for (var i = 0; i < 10; i++)
  console.log(rng.choice(digits));

Answer 2

如果您希望能够指定种子，只需替换对 getSeconds() 和 getMinutes() 的调用即可。 您可以传入一个 int 并使用它的一半 mod 60 作为秒值，另一半 modulo 60 给出另一部分。

话虽这么说，这个方法看起来很垃圾。 生成正确的随机数非常困难。 这样做的明显问题是随机数种子是基于秒和分钟的。 要猜测种子并重新创建随机数流，只需尝试 3600 种不同的秒和分钟组合。 这也意味着只有 3600 种不同的可能种子。 这是可以纠正的，但我从一开始就对这个 RNG 表示怀疑。

如果您想使用更好的 RNG，请尝试 Mersenne Twister。 它是一款经过充分测试且相当稳健的 RNG，具有巨大的轨道和出色的性能。

编辑：我真的应该是正确的，并将其称为伪随机数生成器或 PRNG。

“任何使用算术方法产生随机数的人都处于犯罪状态。”
                    sp;                     sp;                     sp;                     sp;                     sp;                     sp;     ---约翰·冯·诺依曼

Answer 3

我使用 Mersenne Twister 的 JavaScript 端口：
https://gist.github.com/300494
它允许您手动设置种子。 另外，正如其他答案中提到的，Mersenne Twister 是一个非常好的 PRNG。

Answer 4

您列出的代码看起来像 Lehmer RNG< /a>. 如果是这种情况，则 2147483647 是最大的 32 位有符号整数，2147483647 是最大的 32 位素数，48271 是用于生成数字的全周期乘数。

如果这是真的，您可以修改 RandomNumberGenerator 以接受额外参数 seed，然后将 this.seed 设置为 seed< /代码>; 但你必须小心确保种子会产生良好的随机数分布（莱默可能会很奇怪）——但大多数种子都会很好。

Answer 5

以下是可以提供自定义种子的 PRNG。 调用SeedRandom将返回一个随机生成器函数。 可以不带参数调用 SeedRandom ，以便使用当前时间为返回的随机函数提供种子，也可以使用 1 或 2 个非负整数作为参数来调用它，以便使用这些值作为种子整数。 由于浮点精度，只有 1 个值的播种将只允许生成器启动到 2^53 种不同状态之一。

返回的随机生成器函数接受 1 个名为 limit 的整数参数，limit 必须在 1 到 4294965886 范围内，函数将返回 0 到 limit-1 范围内的数字。

function SeedRandom(state1,state2){
    var mod1=4294967087
    var mul1=65539
    var mod2=4294965887
    var mul2=65537
    if(typeof state1!="number"){
        state1=+new Date()
    }
    if(typeof state2!="number"){
        state2=state1
    }
    state1=state1%(mod1-1)+1
    state2=state2%(mod2-1)+1
    function random(limit){
        state1=(state1*mul1)%mod1
        state2=(state2*mul2)%mod2
        if(state1<limit && state2<limit && state1<mod1%limit && state2<mod2%limit){
            return random(limit)
        }
        return (state1+state2)%limit
    }
    return random
}

使用示例：

var generator1=SeedRandom() //Seed with current time
var randomVariable=generator1(7) //Generate one of the numbers [0,1,2,3,4,5,6]
var generator2=SeedRandom(42) //Seed with a specific seed
var fixedVariable=generator2(7) //First value of this generator will always be
                                //1 because of the specific seed.

该生成器具有以下属性：

• 它具有大约 2^64 种不同的可能内部状态。
• 它的周期大约为 2^63，远远超过 JavaScript 程序中任何人实际需要的周期。
• 由于 mod 值为素数，因此无论选择的限制如何，输出中都没有简单的模式。 这与一些更简单的 PRNG 不同，它们表现出一些相当系统的模式。
• 无论限制如何，它都会丢弃一些结果以获得完美的分布。
• 它相对较慢，在我的机器上每秒运行大约 10 000 000 次。

奖金：打字版本< /a>

Answer 6

如果您使用 Typescript 进行编程，我会采用 Christoph Henkelmann 对此线程的回答中引入的 Mersenne Twister 实现作为 Typescript 类：

/**
 * copied almost directly from Mersenne Twister implementation found in https://gist.github.com/banksean/300494
 * all rights reserved to him.
 */
export class Random {
    static N = 624;
    static M = 397;
    static MATRIX_A = 0x9908b0df;
    /* constant vector a */
    static UPPER_MASK = 0x80000000;
    /* most significant w-r bits */
    static LOWER_MASK = 0x7fffffff;
    /* least significant r bits */

    mt = new Array(Random.N);
    /* the array for the state vector */
    mti = Random.N + 1;
    /* mti==N+1 means mt[N] is not initialized */

    constructor(seed:number = null) {
        if (seed == null) {
            seed = new Date().getTime();
        }

        this.init_genrand(seed);
    }

    private init_genrand(s:number) {
        this.mt[0] = s >>> 0;
        for (this.mti = 1; this.mti < Random.N; this.mti++) {
            var s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
            this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
                + this.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             */
            this.mt[this.mti] >>>= 0;
            /* for >32 bit machines */
        }
    }

    /**
     * generates a random number on [0,0xffffffff]-interval
     * @private
     */
    private _nextInt32():number {
        var y:number;
        var mag01 = new Array(0x0, Random.MATRIX_A);
        /* mag01[x] = x * MATRIX_A  for x=0,1 */

        if (this.mti >= Random.N) { /* generate N words at one time */
            var kk:number;

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

            for (kk = 0; kk < Random.N - Random.M; kk++) {
                y = (this.mt[kk] & Random.UPPER_MASK) | (this.mt[kk + 1] & Random.LOWER_MASK);
                this.mt[kk] = this.mt[kk + Random.M] ^ (y >>> 1) ^ mag01[y & 0x1];
            }
            for (; kk < Random.N - 1; kk++) {
                y = (this.mt[kk] & Random.UPPER_MASK) | (this.mt[kk + 1] & Random.LOWER_MASK);
                this.mt[kk] = this.mt[kk + (Random.M - Random.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
            }
            y = (this.mt[Random.N - 1] & Random.UPPER_MASK) | (this.mt[0] & Random.LOWER_MASK);
            this.mt[Random.N - 1] = this.mt[Random.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];

            this.mti = 0;
        }

        y = this.mt[this.mti++];

        /* Tempering */
        y ^= (y >>> 11);
        y ^= (y << 7) & 0x9d2c5680;
        y ^= (y << 15) & 0xefc60000;
        y ^= (y >>> 18);

        return y >>> 0;
    }

    /**
     * generates an int32 pseudo random number
     * @param range: an optional [from, to] range, if not specified the result will be in range [0,0xffffffff]
     * @return {number}
     */
    nextInt32(range:[number, number] = null):number {
        var result = this._nextInt32();
        if (range == null) {
            return result;
        }

        return (result % (range[1] - range[0])) + range[0];
    }

    /**
     * generates a random number on [0,0x7fffffff]-interval
     */
    nextInt31():number {
        return (this._nextInt32() >>> 1);
    }

    /**
     * generates a random number on [0,1]-real-interval
     */
    nextNumber():number {
        return this._nextInt32() * (1.0 / 4294967295.0);
    }

    /**
     * generates a random number on [0,1) with 53-bit resolution
     */
    nextNumber53():number {
        var a = this._nextInt32() >>> 5, b = this._nextInt32() >>> 6;
        return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
    }
}

您可以按如下方式使用它：

var random = new Random(132);
random.nextInt32(); //return a pseudo random int32 number
random.nextInt32([10,20]); //return a pseudo random int in range [10,20]
random.nextNumber(); //return a a pseudo random number in range [0,1]

检查源代码以获取更多方法。

Answer 7

这是一个我喜欢使用的非常有效但简单的 javascript PRNG 函数：

// The seed is the base number that the function works off
// The modulo is the highest number that the function can return

function PRNG(seed, modulo) {
    str = `${(2**31-1&Math.imul(48271,seed))/2**31}`
    .split('')
    .slice(-10)
    .join('') % modulo

    return str
}

我希望这就是您正在寻找的。

Answer 8

谢谢你，@aaaaaaaaaaaa（接受的答案）

我真的需要一个好的非库解决方案（更容易嵌入）

所以......我创建了这个类来存储种子并允许Unity式的“下一步”......但保留了基于初始整数的结果

class randS {
    constructor(seed=null) {
        if(seed!=null) {
            this.seed = seed;
        } else {
            this.seed = Date.now()%4645455524863;
        }
        this.next = this.SeedRandom(this.seed);
        this.last = 0;
    }
    Init(seed=this.seed) {
        if (seed = this.seed) {
            this.next = this.SeedRandom(this.seed);
        } else {
            this.seed=seed;
            this.next = this.SeedRandom(this.seed);
        }
    }
    SeedRandom(state1,state2){
        var mod1=4294967087;
        var mod2=4294965887;
        var mul1=65539;
        var mul2=65537;
        if(typeof state1!="number"){
            state1=+new Date();
        }
        if(typeof state2!="number"){
            state2=state1;
        }
        state1=state1%(mod1-1)+1;
        state2=state2%(mod2-1)+1;
        function random(limit){
            state1=(state1*mul1)%mod1;
            state2=(state2*mul2)%mod2;
            if(state1<limit && state2<limit && state1<mod1%limit && state2<mod2%limit){
                this.last = random;
                return random(limit);
            }
            this.last = (state1+state2)%limit;
            return (state1+state2)%limit;
        }
        this.last = random;
        return random;

    }
}

然后用这些检查它...似乎与随机（但可查询）种子值（a la Minecraft）配合得很好，甚至存储了返回的最后一个值（如果需要），

var rng = new randS(9005646549);
console.log(rng.next(20)+' '+rng.next(20)+' '+rng.next(20)+' '+rng.next(20)+' '+rng.next(20)+' '+rng.next(20)+' '+rng.next(20));
console.log(rng.next(20) + ' ' + rng.next(20) + ' ' + rng.last);

该值应该输出（对于每个人）

6 7 8 14 1 12 6
9 1 1

编辑：如果您需要重新播种或测试值，我使 init() 起作用（这在我的上下文中也是必要的）

Answer 9

注意：此代码最初包含在上述问题中。 为了使问题简短而集中，我已将其移至此社区 Wiki 答案。

我发现这段代码很有效，它似乎可以很好地获取随机数，然后使用种子，但是我不太确定逻辑是如何工作的（例如 2345678901、48271 和 2147483647 数字来自哪里）。

function nextRandomNumber(){
  var hi = this.seed / this.Q;
  var lo = this.seed % this.Q;
  var test = this.A * lo - this.R * hi;
  if(test > 0){
    this.seed = test;
  } else {
    this.seed = test + this.M;
  }
  return (this.seed * this.oneOverM);
}

function RandomNumberGenerator(){
  var d = new Date();
  this.seed = 2345678901 + (d.getSeconds() * 0xFFFFFF) + (d.getMinutes() * 0xFFFF);
  this.A = 48271;
  this.M = 2147483647;
  this.Q = this.M / this.A;
  this.R = this.M % this.A;
  this.oneOverM = 1.0 / this.M;
  this.next = nextRandomNumber;
  return this;
}

function createRandomNumber(Min, Max){
  var rand = new RandomNumberGenerator();
  return Math.round((Max-Min) * rand.next() + Min);
}

//Thus I can now do:
var letters = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];
var numbers = ['1','2','3','4','5','6','7','8','9','10'];
var colors = ['red','orange','yellow','green','blue','indigo','violet'];
var first = letters[createRandomNumber(0, letters.length)];
var second = numbers[createRandomNumber(0, numbers.length)];
var third = colors[createRandomNumber(0, colors.length)];
    
alert("Today's show was brought to you by the letter: " + first + ", the number " + second + ", and the color " + third + "!");

/*
  If I could pass my own seed into the createRandomNumber(min, max, seed);
  function then I could reproduce a random output later if desired.
*/

Answer 10

以下 IIFE 生成一长串可重复的随机 31 位整数。 它使用两个 15 位素数来避免 JS 整数溢出。

let random = (function () {
  let a = 1, b = 1;
  return {
    nextInt: function () {
      a = (a * 67307) & 0xffff;
      b = (b * 67427) & 0xffff;
      return a ^ (b << 15);
    },
    reset(seed) {
      a = b = seed | 0;
    }
  };
})();

下面的代码展示了如何使用它......

random.reset(2); // Reset to start of sequence

// Log sequence of random numbers
for (let i = 0; i < 100; i++)
  console.log(random.nextInt());

Answer 11

好的，这是我确定的解决方案。

首先，使用“newseed()”函数创建一个种子值。 然后将种子值传递给“srandom()”函数。 最后，“srandom()”函数返回 0 到 1 之间的伪随机值。

关键点是种子值存储在数组内。 如果它只是一个整数或浮点数，则每次调用函数时该值都会被覆盖，因为整数、浮点数、字符串等的值直接存储在堆栈中，而不是像数组和指针那样存储在堆栈中其他物体。 因此，种子的价值有可能保持持久。

最后，可以定义“srandom()”函数，使其成为“Math”对象的方法，但我将把它留给您来解决。 ;）

祝你好运！

JavaScript：

// Global variables used for the seeded random functions, below.
var seedobja = 1103515245
var seedobjc = 12345
var seedobjm = 4294967295 //0x100000000

// Creates a new seed for seeded functions such as srandom().
function newseed(seednum)
{
    return [seednum]
}

// Works like Math.random(), except you provide your own seed as the first argument.
function srandom(seedobj)
{
    seedobj[0] = (seedobj[0] * seedobja + seedobjc) % seedobjm
    return seedobj[0] / (seedobjm - 1)
}

// Store some test values in variables.
var my_seed_value = newseed(230951)
var my_random_value_1 = srandom(my_seed_value)
var my_random_value_2 = srandom(my_seed_value)
var my_random_value_3 = srandom(my_seed_value)

// Print the values to console. Replace "WScript.Echo()" with "alert()" if inside a Web browser.
WScript.Echo(my_random_value_1)
WScript.Echo(my_random_value_2)
WScript.Echo(my_random_value_3)

Lua 4（我个人的目标环境）：

-- Global variables used for the seeded random functions, below.
seedobja = 1103515.245
seedobjc = 12345
seedobjm = 4294967.295 --0x100000000

-- Creates a new seed for seeded functions such as srandom().
function newseed(seednum)
    return {seednum}
end

-- Works like random(), except you provide your own seed as the first argument.
function srandom(seedobj)
    seedobj[1] = mod(seedobj[1] * seedobja + seedobjc, seedobjm)
    return seedobj[1] / (seedobjm - 1)
end

-- Store some test values in variables.
my_seed_value = newseed(230951)
my_random_value_1 = srandom(my_seed_value)
my_random_value_2 = srandom(my_seed_value)
my_random_value_3 = srandom(my_seed_value)

-- Print the values to console.
print(my_random_value_1)
print(my_random_value_2)
print(my_random_value_3)