[php] seedrandom.php

Viewer

copydownloadembedprintName: seedrandom.php
  1. <?php 
  2. $var = '* @param {number=} overflow 
  3.  * @param {number=} startdenom
  4.  */
  5.  
  6. //função anônima
  7. (function (pool, math, width, chunks, significance, overflow, startdenom) {
  8.  
  9.   //
  10.   // seedrandom()
  11.   // Esta é a função seedrandom descrita acima.
  12.   //
  13.   math[\'seedrandom\'] = function seedrandom(seed, use_entropy) {
  14.     var key = [];
  15.     var arc4;
  16.   
  17.     // Achatamos a string de semente ou construímos uma a partir da entropia local, se necessário.
  18.     seed = mixkey(flatten(
  19.       use_entropy ? [seed, pool] :
  20.       arguments.length ? seed :
  21.       [new Date().getTime(), pool, window], 3), key);
  22.   
  23.     // Usamos a semente para inicializar um gerador ARC4.
  24.     arc4 = new ARC4(key);
  25.   
  26.     // Misturamos a aleatoriedade na entropia acumulada.
  27.     mixkey(arc4.S, pool);
  28.   
  29.     // Substituímos Math.random
  30.   
  31.     // Esta função retorna um número aleatório em [0, 1) que contém
  32.     // aleatoriedade em cada bit da mantissa do valor IEEE 754.
  33.   
  34.     math[\'random\'] = function random() {  // Closure para retornar um número aleatório:
  35.       var n = arc4.g(chunks);             // Começamos com um numerador n < 2 ^ 48
  36.       var d = startdenom;                 //   e denominador d = 2 ^ 48.
  37.       var x = 0;                          //   e sem \'último byte extra\'.
  38.       while (n < significance) {          // Preenchemos todos os dígitos significativos por
  39.         n = (n + x) * width;              //   deslocamento do numerador e
  40.         d *= width;                       //   denominador e gerando um
  41.         x = arc4.g(1);                    //   novo byte menos significativo.
  42.       }
  43.       while (n >= overflow) {             // Para evitar arredondamento para cima, antes de adicionar
  44.         n /= 2;                           //   último byte, deslocamos tudo
  45.         d /= 2;                           //   para a direita usando matemática de inteiros até
  46.         x >>>= 1;                         //   termos exatamente os bits desejados.
  47.       }
  48.       return (n + x) / d;                 // Formamos o número dentro de [0, 1).
  49.     };
  50.   
  51.     // Retornamos a semente que foi usada
  52.     return seed;
  53.   };
  54.   
  55.   //
  56.   // ARC4
  57.   //
  58.   // Uma implementação ARC4. O construtor recebe uma chave na forma de
  59.   // uma matriz de no máximo (largura) inteiros que devem ser 0 <= x < (largura).
  60.   //
  61.   // O método g(contagem) retorna um número pseudorrandômico que concatena
  62.   // as próximas (contagem) saídas de ARC4. Seu valor de retorno é um número x
  63.   // que está no intervalo 0 <= x < (largura ^ contagem).
  64.   //
  65.   /** @constructor */
  66.   function ARC4(key) {
  67.     var t, u, me = this, keylen = key.length;
  68.     var i = 0, j = me.i = me.j = me.m = 0;
  69.     me.S = [];
  70.     me.c = [];
  71.   
  72.     // A chave vazia [] é tratada como [0].
  73.     if (!keylen) { key = [keylen++]; }
  74.   
  75.     // Configuramos S usando o algoritmo padrão de programação de chaves.
  76.     while (i < width) { me.S[i] = i++; }
  77.     for (i = 0; i < width; i++) {
  78.       t = me.S[i];
  79.       j = lowbits(j + t + key[i % keylen]);
  80.       u = me.S[j];
  81.       me.S[i] = u;
  82.       me.S[j] = t;
  83.     }
  84.   
  85.     // O método "g" retorna as próximas (contagem) saídas como um número.
  86.     me.g = function getnext(count) {
  87.       var s = me.S;
  88.       var i = lowbits(me.i + 1); var t = s[i];
  89.       var j = lowbits(me.j + t); var u = s[j];
  90.       s[i] = u;
  91.       s[j] = t;
  92.       var r = s[lowbits(t + u)];
  93.       while (--count) {
  94.         i = lowbits(i + 1); t = s[i];
  95.         j = lowbits(j + t); u = s[j];
  96.         s[i] = u;
  97.         s[j] = t;
  98.         r = r * width + s[lowbits(t + u)];
  99.       }
  100.       me.i = i;
  101.       me.j = j;
  102.       return r;
  103.     };
  104.     // Para imprevisibilidade robusta, descartamos um lote inicial de valores.
  105.     // Veja http://www.rsa.com/rsalabs/node.asp?id=2009
  106.     me.g(width);
  107.   }
  108.   
  109.   //
  110.   // flatten()
  111.   // Converte uma árvore de objetos em matrizes aninhadas de strings.
  112.   //
  113.   /** @param {Object=} result 
  114.     * @param {string=} prop */
  115.   function flatten(obj, depth, result, prop) {
  116.     result = [];
  117.     if (depth && typeof(obj) == \'object\') {
  118.       for (prop in obj) {
  119.         if (prop.indexOf(\'S\') < 5) {    // Evitamos o bug do FF3 (local/sessionStorage)
  120.           try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
  121.         }
  122.       }
  123.     }
  124.     return result.length ? result : \'\' + obj;
  125.   }
  126.   
  127.   //
  128.   // mixkey()
  129.   // Mistura uma semente de string em uma chave que é uma matriz de inteiros, e
  130.   // retorna uma semente de string encurtada que é equivalente à chave resultante.
  131.   //
  132.   /** @param {number=} smear 
  133.     * @param {number=} j */
  134.   function mixkey(seed, key, smear, j) {
  135.     seed += \'\';                         // Garantimos que a semente seja uma string
  136.     smear = 0;
  137.     for (j = 0; j < seed.length; j++) {
  138.       key[lowbits(j)] =
  139.         lowbits((smear ^= key[lowbits(j)] * 19) + seed.charCodeAt(j));
  140.     }
  141.     seed = \'\';
  142.     for (j in key) { seed += String.fromCharCode(key[j]); }
  143.     console.log(seed);
  144.     return seed;
  145.   }
  146.   
  147.   //
  148.   // lowbits()
  149.   // Um rápido "n mod largura" para largura uma potência de 2.
  150.   //
  151.   function lowbits(n) { return n & (width - 1); }
  152.   
  153.   //
  154.   // As seguintes constantes estão relacionadas aos limites IEEE 754.
  155.   //
  156.   startdenom = math.pow(width, chunks);
  157.   significance = math.pow(2, significance);
  158.   overflow = significance * 2;
  159.   
  160.   //
  161.   // Quando seedrandom.js é carregado, misturamos imediatamente alguns bits
  162.   // do RNG incorporado no pool de entropia. Porque não queremos interferir
  163.   // com o estado determinístico do PRNG mais tarde,
  164.   // seedrandom não chamará math.random por conta própria novamente após
  165.   // a inicialização.
  166.   //
  167.   mixkey(math.random(), pool);
  168.  
  169.   // Fim do escopo anônimo e passagem de valores iniciais.
  170.   })(
  171.   [], // pool: o pool de entropia começa vazio
  172.   Math, // math: pacote contendo random, pow e seedrandom
  173.   256, // width: cada saída RC4 é 0 <= x < 256
  174.   6, // chunks: pelo menos seis saídas RC4 para cada número duplo
  175.   52 // significance: há 52 dígitos significativos em um número duplo
  176.   );';

Editor

You can edit this paste and save as new:


File Description
  • seedrandom.php
  • Paste Code
  • 30 Apr-2024
  • 6.06 Kb
You can Share it: