在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(简单快速计数器)

sfc32PractRand随机数测试套件的一部分(当然它可以通过)。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”,他是制作ISAACSpookyHash的人通过了 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.sinMath.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,这代表你必须扔掉,以避免单模式数字的最小量-看到值结果101001000)。简洁也不错。

它比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

上一篇:
下一篇:

评论已关闭!