在Javascript中播种随机数生成器

2020/09/29 08:41 · javascript ·  · 0评论

是否可以在Javascript中植入随机数生成器（Math.random）？

不，不是，但是编写自己的生成器相当容易，或者最好使用现有的生成器。签出：此相关问题。

另外，请参阅David Bau的博客，以获取有关播种的更多信息。

我已经在纯JavaScript中实现了许多良好，简短和快速的伪随机数生成器（PRNG）函数。它们都可以播种并提供高质量的编号。

首先，请注意正确初始化PRNG。下面的大多数生成器没有内置的种子生成过程（为简单起见），但是接受一个或多个32位值作为PRNG 的初始状态。相似的种子（例如1和2的简单种子）可以在较弱的PRNG中引起相关性，从而导致输出具有相似的属性（例如，随机生成的水平相似）。为避免这种情况，最佳做法是使用分布良好的种子初始化PRNG。

幸运的是，哈希函数非常擅长从短字符串生成PRNG的种子。即使两个字符串相似，一个好的哈希函数也会产生非常不同的结果。这是一个基于MurmurHash3的混合函数的示例：

function xmur3(str) {
    for(var i = 0, h = 1779033703 ^ str.length; i < str.length; i++)
        h = Math.imul(h ^ str.charCodeAt(i), 3432918353),
        h = h << 13 | h >>> 19;
    return function() {
        h = Math.imul(h ^ h >>> 16, 2246822507);
        h = Math.imul(h ^ h >>> 13, 3266489909);
        return (h ^= h >>> 16) >>> 0;
    }
}

后续每次对return函数的调用都会xmur3产生一个新的“随机” 32位哈希值，以用作PRNG中的种子。使用方法如下：

// Create xmur3 state:
var seed = xmur3("apples");
// Output four 32-bit hashes to provide the seed for sfc32.
var rand = sfc32(seed(), seed(), seed(), seed());

// Output one 32-bit hash to provide the seed for mulberry32.
var rand = mulberry32(seed());

// Obtain sequential random numbers like so:
rand();
rand();

或者，只需选择一些虚拟数据来填充种子，然后使生成器前进几次（12-20次迭代）以完全混合初始状态。这在PRNG的参考实现中经常看到，但是它确实限制了初始状态的数量。

var seed = 1337 ^ 0xDEADBEEF; // 32-bit seed with optional XOR value
// Pad seed with Phi, Pi and E.
// https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
var rand = sfc32(0x9E3779B9, 0x243F6A88, 0xB7E15162, seed);
for (var i = 0; i < 15; i++) rand();

这些PRNG函数的输出产生一个正的32位数字（0到2 32 -1）Math.random()，如果需要随机数，则将其转换为0-1（包括0，包括1，不包括在内）之间的浮点数。有关特定范围的信息，请阅读有关MDN的文章。如果只需要原始位，只需删除最后的除法操作即可。

要注意的另一件事是JS的局限性。数字只能代表最高53位分辨率的整数。并且在使用按位运算时，该值减少为32。这使得难以实现使用C或C ++编写的使用64位数字的算法。移植64位代码需要填充，这会大大降低性能。因此，为了简单和高效，我只考虑了使用32位数学的算法，因为它直接与JS兼容。

现在，继续到发电机。（我在这里维护完整列表，并提供参考资料）

sfc32（简单快速计数器）

sfc32是PractRand随机数测试套件的一部分（当然它可以通过）。sfc32具有128位状态，并且在JS中非常快。

function sfc32(a, b, c, d) {
    return function() {
      a >>>= 0; b >>>= 0; c >>>= 0; d >>>= 0; 
      var t = (a + b) | 0;
      a = b ^ b >>> 9;
      b = c + (c << 3) | 0;
      c = (c << 21 | c >>> 11);
      d = d + 1 | 0;
      t = t + d | 0;
      c = c + t | 0;
      return (t >>> 0) / 4294967296;
    }
}

桑树32

Mulberry32是具有32位状态的简单生成器，但速度极快且具有良好的质量（作者声明它已通过gjrand测试套件的所有测试，并具有完整的2 32周期，但我尚未验证）。

function mulberry32(a) {
    return function() {
      var t = a += 0x6D2B79F5;
      t = Math.imul(t ^ t >>> 15, t | 1);
      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
      return ((t ^ t >>> 14) >>> 0) / 4294967296;
    }
}

如果您只需要一个简单但不错的 PRNG而不需要数十亿个随机数（请参阅生日问题），我将建议您这样做。

xoshiro128 **

截至2018年5月，xoshiro128 **是Vigna＆Blackman 的Xorshift系列的新成员（Vigna教授还负责Xorshift128 +算法的功能，该算法为Math.random引擎盖下的大多数实现提供了动力）。它是提供128位状态的最快生成器。

function xoshiro128ss(a, b, c, d) {
    return function() {
        var t = b << 9, r = a * 5; r = (r << 7 | r >>> 25) * 9;
        c ^= a; d ^= b;
        b ^= c; a ^= d; c ^= t;
        d = d << 11 | d >>> 21;
        return (r >>> 0) / 4294967296;
    }
}

作者声称它很好地通过了随机性测试（尽管有警告）。其他研究人员指出，TestU01中的某些测试（尤其是LinearComp和BinaryRank）未通过。实际上，使用浮点数（例如这些实现）时不会引起问题，但是如果依赖原始低位，可能会引起问题。

JSF（詹金斯的小快车）

这是鲍勃·詹金斯（Bob Jenkins，2007年）的JSF或“ smallprng”，他是制作ISAAC和SpookyHash的人。它通过了 PractRand测试，应该相当快，尽管不如SFC快。

function jsf32(a, b, c, d) {
    return function() {
        a |= 0; b |= 0; c |= 0; d |= 0;
        var t = a - (b << 27 | b >>> 5) | 0;
        a = b ^ (c << 17 | c >>> 15);
        b = c + d | 0;
        c = d + t | 0;
        d = a + t | 0;
        return (d >>> 0) / 4294967296;
    }
}

LCG（aka Lehmer / Park-Miller RNG或MCG）

LCG 非常快速和简单，但是其随机性的质量非常低，以至于使用不当实际上会导致程序中的错误！但是，它比建议使用Math.sin或Math.PI！的答案好得多。不过这是单线的，很好:)。

var LCG=s=>()=>(2**31-1&(s=Math.imul(48271,s)))/2**31;

该实现称为Park-Miller在1988和1993年提出的最低标准 RNG，并在C ++ 11中实现为。请记住，状态为31位（31位给出20亿个可能的状态，32位给出两倍的状态）。这是其他人试图替代的PRNG类型！minstd_rand

它会起作用，但是除非您确实需要速度并且不在乎随机性质量（无论是什么随机性），否则我不会使用它。非常适合游戏果酱或演示之类的东西。LCG具有种子相关性，因此最好丢弃 LCG 的第一个结果。而且，如果您坚持使用LCG，则增加一个增量值可能会改善结果，但是当存在更好的选择时，这可能是徒劳的。

似乎还有其他乘法器提供32位状态（增加的状态空间）： 

var LCG=s=>()=>(s=Math.imul(741103597,s)>>>0)/2**32;
var LCG=s=>()=>(s=Math.imul(1597334677,s)>>>0)/2**32;

这些LCG值来自：P. L'Ecuyer：不同大小和良好晶格结构的线性同余生成器表，1997年4月30日。

注意：尽管（或由于其简洁性）和明显的优雅，但就随机性而言，该算法绝不是一种高质量的算法。寻找例如该答案中列出的那些以获得更好的结果。

（最初从评论中提出的一个聪明的想法改编为另一个答案。）

var seed = 1;
function random() {
    var x = Math.sin(seed++) * 10000;
    return x - Math.floor(x);
}

您可以将其设置seed为任何数字，只需避免为零（或Math.PI的任何倍数）即可。

该解决方案的优雅，在我看来，来自于没有任何“神奇”的数字（除了10000，这代表你必须扔掉，以避免单模式数字的最小量-看到值结果10，100，1000）。简洁也不错。

它比Math.random（）慢2到3倍，但我相信它的速度与其他用JavaScript编写的解决方案一样快。

不，但是这里有一个简单的伪随机数生成器，是我从维基百科改编的随身携带实现（此后已删除）：

var m_w = 123456789;
var m_z = 987654321;
var mask = 0xffffffff;

// Takes any integer
function seed(i) {
    m_w = (123456789 + i) & mask;
    m_z = (987654321 - i) & mask;
}

// Returns number between 0 (inclusive) and 1.0 (exclusive),
// just like Math.random().
function random()
{
    m_z = (36969 * (m_z & 65535) + (m_z >> 16)) & mask;
    m_w = (18000 * (m_w & 65535) + (m_w >> 16)) & mask;
    var result = ((m_z << 16) + (m_w & 65535)) >>> 0;
    result /= 4294967296;
    return result;
}

编辑：通过使其重置m_z来固定种子函数编辑2：

严重的实现缺陷已得到修复

AnttiSykäri的算法很好而且很短。最初，我做了一个变体，Math.random当您调用时替换了JavaScript Math.seed(s)，但随后Jason评论说，返回该函数会更好：

Math.seed = function(s) {
    return function() {
        s = Math.sin(s) * 10000; return s - Math.floor(s);
    };
};

// usage:
var random1 = Math.seed(42);
var random2 = Math.seed(random1());
Math.random = Math.seed(random2());

这为您提供了JavaScript所没有的另一功能：多个独立的随机生成器。如果您想同时运行多个可重复的仿真，这一点尤其重要。

请参阅Pierre L'Ecuyer的工作可以追溯到1980年代末和1990年代初。还有其他。如果您不是专家，则自己创建（伪）随机数生成器非常危险，因为很有可能结果不是统计上随机的，或者是周期很小。Pierre（和其他人）已经组合了一些易于实现的优质（伪）随机数生成器。我使用他的LFSR发生器之一。

https://www.iro.umontreal.ca/~lecuyer/myftp/papers/handstat.pdf

菲尔·特洛伊

结合之前的一些答案，这是您正在寻找的可播种随机函数：

Math.seed = function(s) {
    var mask = 0xffffffff;
    var m_w  = (123456789 + s) & mask;
    var m_z  = (987654321 - s) & mask;

    return function() {
      m_z = (36969 * (m_z & 65535) + (m_z >>> 16)) & mask;
      m_w = (18000 * (m_w & 65535) + (m_w >>> 16)) & mask;

      var result = ((m_z << 16) + (m_w & 65535)) >>> 0;
      result /= 4294967296;
      return result;
    }
}

var myRandomFunction = Math.seed(1234);
var randomNumber = myRandomFunction();

编写自己的伪随机生成器非常简单。

Dave Scotese的建议很有用，但正如其他人所指出的那样，它的分布并不均匀。

但是，这不是因为sin的整数参数。仅仅是因为罪恶的范围，恰好是圆的一维投影。如果采用圆角，则它将是均匀的。

因此，请使用arg（exp（i * x））/（2 * PI）代替sin（x）。

如果您不喜欢线性顺序，请将其与xor混合使用。实际因素也无关紧要。

要生成n个伪随机数，可以使用以下代码：

function psora(k, n) {
  var r = Math.PI * (k ^ n)
  return r - Math.floor(r)
}
n = 42; for(k = 0; k < n; k++) console.log(psora(k, n))

还请注意，当需要实数熵时，不能使用伪随机序列。

如今，许多需要Javascript中带有可播种随机数生成器的人都在使用David Bau的seedrandom模块。

Math.random不，但是运行库解决了这个问题。它几乎具有您可以想象的所有分布，并支持种子式随机数生成。例：

ran.core.seed(0)
myDist = new ran.Dist.Uniform(0, 1)
samples = myDist.sample(1000)

我编写了一个返回种子随机数的函数，该函数使用Math.sin拥有一个长随机数，并使用种子从中挑选数字。

用 ：

seedRandom("k9]:2@", 15)

它将返回您的种子编号，第一个参数是任何字符串值; 你的种子。第二个参数是将返回多少个数字。

     function seedRandom(inputSeed, lengthOfNumber){

           var output = "";
           var seed = inputSeed.toString();
           var newSeed = 0;
           var characterArray = ['0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','y','x','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','U','R','S','T','U','V','W','X','Y','Z','!','@','#','$','%','^','&','*','(',')',' ','[','{',']','}','|',';',':',"'",',','<','.','>','/','?','`','~','-','_','=','+'];
           var longNum = "";
           var counter = 0;
           var accumulator = 0;

           for(var i = 0; i < seed.length; i++){
                var a = seed.length - (i+1);
                for(var x = 0; x < characterArray.length; x++){
                     var tempX = x.toString();
                     var lastDigit = tempX.charAt(tempX.length-1);
                     var xOutput = parseInt(lastDigit);
                     addToSeed(characterArray[x], xOutput, a, i); 
                }                  
           }

                function addToSeed(character, value, a, i){
                     if(seed.charAt(i) === character){newSeed = newSeed + value * Math.pow(10, a)}
                }
                newSeed = newSeed.toString();

                var copy = newSeed;
           for(var i=0; i<lengthOfNumber*9; i++){
                newSeed = newSeed + copy;
                var x = Math.sin(20982+(i)) * 10000;
                var y = Math.floor((x - Math.floor(x))*10);
                longNum = longNum + y.toString()
           }

           for(var i=0; i<lengthOfNumber; i++){
                output = output + longNum.charAt(accumulator);
                counter++;
                accumulator = accumulator + parseInt(newSeed.charAt(counter));
           }
           return(output)
      }

固定种子的简单方法：

function fixedrandom(p){
    const seed = 43758.5453123;
    return (Math.abs(Math.sin(p)) * seed)%1;
}

对于0到100之间的数字。

Number.parseInt(Math.floor(Math.random() * 100))
本文地址：http://javascript.askforanswer.com/zaijavascriptzhongbozhongsuijishushengchengqi.html
文章标签： ,  
版权声明：本文为原创文章，版权归 javascript 所有，欢迎分享本文，转载请保留出处！

文件下载

老薛主机终身7折优惠码boke112

上一篇：
下一篇：

评论已关闭！