Javascript에서 난수 생성기 시드하기
JavaScript에서 난수 생성기()Math.random를 시드할 수 있습니까?
씨를 뿌릴 수 요.Math.random()ECMAScript 사양은 주제에 대해 의도적으로 모호하기 때문에 시딩 수단을 제공하지 않으며 브라우저에서도 동일한 알고리즘을 사용할 필요가 없습니다.따라서 이러한 기능은 외부적으로 제공되어야 하며, 다행히 그렇게 어렵지 않습니다.
플레인 JavaScript에서 다수의 pseudorandom number generator(PRNG) 함수를 구현했습니다.모두 씨앗을 뿌릴 수 있어 고품질 수치를 얻을 수 있습니다.이들은 보안 목적을 위한 것이 아닙니다.시드 가능한 CSPRNG가 필요한 경우 ISAK을 참조하십시오.
우선 PRNG를 올바르게 초기화하도록 주의합니다.단순하게 하기 위해 아래 생성기에는 시드 생성 절차가 내장되어 있지 않지만 PRNG의 초기 시드 상태로 하나 이상의 32비트 숫자를 받아들입니다. 유사 시드 또는 스파스 시드(예를 들어 1과 2의 단순한 시드)는 엔트로피가 낮으며 상관관계 또는 기타 랜덤성 품질 문제를 일으킬 수 있으며, 때로는 출력에 simila가 발생할 수 있습니다.r 속성(임의로 생성된 수준이 유사한 경우 등)이를 피하기 위해 PRNG가 잘 분포되어 있고 엔트로피가 높은 시드 및/또는 처음 15개 정도의 수치보다 앞서가는 것을 초기화하는 것이 가장 좋은 방법입니다.
여기에는 여러 가지 방법이 있지만 여기 두 가지 방법이 있습니다.먼저 해시함수는 짧은 문자열에서 시드를 생성하는 데 매우 능숙합니다.해시함수가 좋으면 두 문자열이 비슷해도 매우 다른 결과가 생성되기 때문에 문자열에 많은 신경을 쓸 필요가 없습니다.해시 함수의 예를 다음에 나타냅니다.
function cyrb128(str) {
let h1 = 1779033703, h2 = 3144134277,
h3 = 1013904242, h4 = 2773480762;
for (let i = 0, k; i < str.length; i++) {
k = str.charCodeAt(i);
h1 = h2 ^ Math.imul(h1 ^ k, 597399067);
h2 = h3 ^ Math.imul(h2 ^ k, 2869860233);
h3 = h4 ^ Math.imul(h3 ^ k, 951274213);
h4 = h1 ^ Math.imul(h4 ^ k, 2716044179);
}
h1 = Math.imul(h3 ^ (h1 >>> 18), 597399067);
h2 = Math.imul(h4 ^ (h2 >>> 22), 2869860233);
h3 = Math.imul(h1 ^ (h3 >>> 17), 951274213);
h4 = Math.imul(h2 ^ (h4 >>> 19), 2716044179);
return [(h1^h2^h3^h4)>>>0, (h2^h1)>>>0, (h3^h1)>>>0, (h4^h1)>>>0];
}
" "cyrb128할 수 은 다음과 .PRNG는 다음과 같습니다.사용 방법은 다음과 같습니다.
// Create cyrb128 state:
var seed = cyrb128("apples");
// Four 32-bit component hashes provide the seed for sfc32.
var rand = sfc32(seed[0], seed[1], seed[2], seed[3]);
// Only one 32-bit component hash is needed for mulberry32.
var rand = mulberry32(seed[0]);
// Obtain sequential random numbers like so:
rand();
rand();
주의: 조금 더 견고한 128비트 해시를 원하는 경우 MurmurHash3_x86_128을 고려하십시오.이것은 보다 철저하지만 대규모 어레이에서 사용하기 위한 것입니다.
또는 시드 패드에 사용할 더미 데이터를 선택하고 제너레이터를 몇 번(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-132)를 생성합니다.이 숫자는 0-1(0 포함, 1 배타적) 사이의 부동소수점 숫자로 변환됩니다.이는 다음과 같습니다.Math.random()특정 범위의 난수를 필요로 하는 경우는 MDN에 관한 이 문서를 참조해 주세요.원래 비트만을 필요로 하는 경우는, 최종 분할 조작을 삭제해 주세요.
JavaScript 번호는 최대 53비트 해상도의 정수만 나타낼 수 있습니다.비트 연산을 사용하면 32로 줄어듭니다.다른 언어의 최신 PRNG는 64비트 연산을 사용하는 경우가 많은데, JS로 포팅할 때 심이 필요하므로 성능이 크게 저하될 수 있습니다.이 알고리즘은 JS와 직접 호환되므로 32비트 연산만 사용합니다.
이제 생성기로 이동합니다. (여기 참조 및 라이센스 정보가 포함된 전체 목록을 유지합니다.)
sfc32(단순 고속 카운터)
sfc32는 PracticeRand 난수 테스트 스위트의 일부입니다(물론 통과).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;
}
}
'이 있을까?' 이런 생각이 들도 있어요.| 0 ★★★★★★★★★★★★★★★★★」>>>= 0를 위한 것입니다.이들은 기본적으로 성능 최적화에 사용되는 32비트 정수 캐스트입니다. NumberJS에서는 기본적으로 플로트이지만 비트 조작 중에는 32비트 정수 모드로 전환됩니다.이 모드는 JS 인터프리터에 의해 보다 빠르게 처리되지만 곱셈 또는 덧셈으로 인해 다시 플로트로 전환되어 성능 저하가 발생합니다.
멀버리32
Mulberry32는 32비트 상태의 심플한 제너레이터이지만 매우 빠르고 품질 랜덤성이 뛰어납니다(저자는 gjrand 테스트 스위트의 모든 테스트에 합격하여32 2주기가 완료되었지만 검증은 하지 않았습니다).
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에 의해 Xorsshift 패밀리의 새로운 멤버입니다(Vigna 교수는 Xorsshift128+ 알고리즘의 대부분을 담당하고 있습니다).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(젠킨스의 스몰 패스트)
아이작과 스푸키해쉬를 만든 밥 젠킨스(2007)의 JSF 또는 'smallprng'입니다.PracticeRand 테스트에 합격하여 sfc32만큼 빠르지는 않지만 상당히 빠릅니다.
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;
}
}
씨를 뿌릴 수 요.Math.random()다만, 독자적인 제너레이터를 작성하는 것은 매우 간단합니다.기존의 제너레이터를 사용하는 것이 좋습니다.
확인: 이 관련 질문입니다.
또한 씨뿌리기에 대한 자세한 내용은 David Bau의 블로그를 참조하십시오.
메모: 간결함과 외관상 우아함에도 불구하고 이 알고리즘은 랜덤성 측면에서 결코 고품질의 알고리즘이 아닙니다.예를 들어, 더 나은 결과를 얻기 위해 이 답변에 나열된 항목을 찾습니다.
(원래는 코멘트에서 제시된 기발한 아이디어에서 다른 답변으로 수정되었습니다.)
var seed = 1;
function random() {
var x = Math.sin(seed++) * 10000;
return x - Math.floor(x);
}
설정할 수 .seed임의의 숫자가 되려면 0(또는 수학의 배수)을 피하십시오. PI)
이 솔루션의 우아함은 "매직" 숫자가 없기 때문에 생겨난다고 생각합니다(단, 홀수 패턴을 피하기 위해 버려야 하는 최소 자릿수를 나타내는 10000을 제외하고 10, 100, 1000의 값을 가진 결과를 참조하십시오).간결함도 좋다.
Math.random()보다는 조금 느리지만 (2배 또는 3배), 자바스크립트로 작성된 다른 솔루션과 거의 같은 속도라고 생각합니다.
아니요, 하지만 여기 간단한 의사 난수 생성기가 있습니다. Wikipedia에서 개조한 Multiply-with-carry의 구현입니다(이후 삭제되었습니다).
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;
}
안티 시케리는 처음에의 JavaScript를 .Math.random했을 때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에 없는 다른 기능인 여러 개의 독립적인 랜덤 생성기를 제공합니다.이는 여러 개의 반복 가능한 시뮬레이션을 동시에 실행하는 경우에 특히 중요합니다.
1980년대 후반에서 1990년대 초반으로 거슬러 올라가는 피에르 레퀴어의 작품을 보세요.다른 사람들도 있어요.전문가가 아닌 경우 직접 (의사) 난수 생성기를 만드는 것은 매우 위험합니다. 왜냐하면 결과가 통계적으로 랜덤하지 않거나 기간이 짧을 가능성이 높기 때문입니다.Pierre(및 기타)는 구현하기 쉬운 좋은(의사) 난수 생성기를 몇 개 조립했습니다.그의 LFSR 발전기 중 하나를 사용합니다.
https://www.iro.umontreal.ca/~lecuyer/myftp/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의 제안은 유용하지만, 다른 사람들이 지적했듯이, 꽤 균등하게 분포되어 있지는 않다.
하지만, 그것은 죄의 정수 논쟁 때문이 아니다.그것은 단순히 죄의 범위 때문인데, 그것은 원의 1차원 투영이다.당신이 원의 각도를 대신 재는다면 그것은 균일할 것이다.
sin(x) 대신 arg(exp(i * x)) / (2 * PI)를 사용합니다.
선형 순서가 마음에 들지 않으면 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))
또한 실제 엔트로피가 필요한 경우 의사 랜덤 시퀀스를 사용할 수 없습니다.
내장된 Math.random 함수는 시드할 수 없지만 코드 수가 매우 적은 Javascript에서는 고품질의 RNG를 구현할 수 있습니다.
Javascript 숫자는 64비트 부동소수점 정밀도로, 2^53보다 작은 모든 양의 정수를 나타낼 수 있습니다.이로 인해 산술에 한계가 있지만 이 한계 내에서 고품질 레머 / LCG 난수 발생기의 파라미터를 선택할 수 있습니다.
function RNG(seed) {
var m = 2**35 - 31
var a = 185852
var s = seed % m
return function () {
return (s = s * a % m) / m
}
}
Math.random = RNG(Date.now())
더 높은 품질의 난수를 원하는 경우 최대 10배 더 느리지만 BigInt를 사용하여 산술적으로 m이 단지 2배 안에 들어갈 수 있는 파라미터를 선택할 수 있습니다.
function RNG(seed) {
var m_as_number = 2**53 - 111
var m = 2n**53n - 111n
var a = 5667072534355537n
var s = BigInt(seed) % m
return function () {
return Number(s = s * a % m) / m_as_number
}
}
위의 구현에서 사용되는 파라미터에 대해서는 Pierre l'Ecuyer의 이 문서를 참조하십시오.https://www.ams.org/journals/mcom/1999-68-225/S0025-5718-99-00996-5/S0025-5718-99-00996-5.pdf
Math.sin을 사용하는 다른 모든 답은 피하십시오!
요즘 Javascript에서 시드 가능한 난수 생성기를 필요로 하는 많은 사람들이 David Bau의 시드랜덤 모듈을 사용하고 있다.
Math.random아뇨, 하지만 운영하는 도서관이 해결해줘요상상할 수 있는 거의 모든 분포를 가지고 있으며 시드 난수 생성을 지원합니다.예:
ran.core.seed(0)
myDist = new ran.Dist.Uniform(0, 1)
samples = myDist.sample(1000)
여기 젠킨스 해시의 채택된 버전이 있습니다 여기서 빌린 겁니다.
export function createDeterministicRandom(): () => number {
let seed = 0x2F6E2B1;
return function() {
// Robert Jenkins’ 32 bit integer hash function
seed = ((seed + 0x7ED55D16) + (seed << 12)) & 0xFFFFFFFF;
seed = ((seed ^ 0xC761C23C) ^ (seed >>> 19)) & 0xFFFFFFFF;
seed = ((seed + 0x165667B1) + (seed << 5)) & 0xFFFFFFFF;
seed = ((seed + 0xD3A2646C) ^ (seed << 9)) & 0xFFFFFFFF;
seed = ((seed + 0xFD7046C5) + (seed << 3)) & 0xFFFFFFFF;
seed = ((seed ^ 0xB55A4F09) ^ (seed >>> 16)) & 0xFFFFFFFF;
return (seed & 0xFFFFFFF) / 0x10000000;
};
}
다음과 같이 사용할 수 있습니다.
const deterministicRandom = createDeterministicRandom()
deterministicRandom()
// => 0.9872818551957607
deterministicRandom()
// => 0.34880331158638
대부분의 답변은 편향된 결과를 낳습니다.다음은 github의 seedrandom 라이브러리를 기반으로 테스트된 함수입니다.
!function(f,a,c){var s,l=256,p="random",d=c.pow(l,6),g=c.pow(2,52),y=2*g,h=l-1;function n(n,t,r){function e(){for(var n=u.g(6),t=d,r=0;n<g;)n=(n+r)*l,t*=l,r=u.g(1);for(;y<=n;)n/=2,t/=2,r>>>=1;return(n+r)/t}var o=[],i=j(function n(t,r){var e,o=[],i=typeof t;if(r&&"object"==i)for(e in t)try{o.push(n(t[e],r-1))}catch(n){}return o.length?o:"string"==i?t:t+"\0"}((t=1==t?{entropy:!0}:t||{}).entropy?[n,S(a)]:null==n?function(){try{var n;return s&&(n=s.randomBytes)?n=n(l):(n=new Uint8Array(l),(f.crypto||f.msCrypto).getRandomValues(n)),S(n)}catch(n){var t=f.navigator,r=t&&t.plugins;return[+new Date,f,r,f.screen,S(a)]}}():n,3),o),u=new m(o);return e.int32=function(){return 0|u.g(4)},e.quick=function(){return u.g(4)/4294967296},e.double=e,j(S(u.S),a),(t.pass||r||function(n,t,r,e){return e&&(e.S&&v(e,u),n.state=function(){return v(u,{})}),r?(c[p]=n,t):n})(e,i,"global"in t?t.global:this==c,t.state)}function m(n){var t,r=n.length,u=this,e=0,o=u.i=u.j=0,i=u.S=[];for(r||(n=[r++]);e<l;)i[e]=e++;for(e=0;e<l;e++)i[e]=i[o=h&o+n[e%r]+(t=i[e])],i[o]=t;(u.g=function(n){for(var t,r=0,e=u.i,o=u.j,i=u.S;n--;)t=i[e=h&e+1],r=r*l+i[h&(i[e]=i[o=h&o+t])+(i[o]=t)];return u.i=e,u.j=o,r})(l)}function v(n,t){return t.i=n.i,t.j=n.j,t.S=n.S.slice(),t}function j(n,t){for(var r,e=n+"",o=0;o<e.length;)t[h&o]=h&(r^=19*t[h&o])+e.charCodeAt(o++);return S(t)}function S(n){return String.fromCharCode.apply(0,n)}if(j(c.random(),a),"object"==typeof module&&module.exports){module.exports=n;try{s=require("crypto")}catch(n){}}else"function"==typeof define&&define.amd?define(function(){return n}):c["seed"+p]=n}("undefined"!=typeof self?self:this,[],Math);
function randIntWithSeed(seed, max=1) {
/* returns a random number between [0,max] including zero and max
seed can be either string or integer */
return Math.round(new Math.seedrandom('seed' + seed)()) * max
}
이 코드의 진정한 랜덤성을 테스트합니다.https://es6console.com/kkjkgur2/
아니요, 그들이 말한 것처럼 Math.random()을 시드하는 것은 불가능하지만 그것을 프로비저닝하는 외부 패키지를 설치할 수 있습니다.이 명령어를 사용하여 설치할 수 있는 패키지를 사용했습니다.
npm i random-seed
이 예는 패키지 매뉴얼에서 가져온 것입니다.
var seed = 'Hello World',
rand1 = require('random-seed').create(seed),
rand2 = require('random-seed').create(seed);
console.log(rand1(100), rand2(100));
https://www.npmjs.com/package/random-seed 에서 문서를 참조할 수 있습니다.
시드된 난수를 반환하는 함수를 작성했습니다.이것은 긴 난수를 가지기 위해 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;
}
PHP에는 기능이 있습니다.srand(seed)특정 시드의 고정 랜덤 값을 생성합니다.그러나 JS에는 이러한 기능이 내장되어 있지 않습니다.
단, 간단한 함수와 짧은 함수는 쓸 수 있습니다.
순서 1: 시드(Fix Number)를 선택합니다.
var seed = 100;
숫자는 1보다 큰 양의 정수여야 합니다.단계 2에서 자세히 설명합니다.
스텝 2: Seed에서 Math.sin() 함수를 실행하면 해당 숫자의 sin 값이 지정됩니다.변수 x에 이 값을 저장합니다.
var x;
x = Math.sin(seed); // Will Return Fractional Value between -1 & 1 (ex. 0.4059..)
sin() 메서드는 -1과 1 사이의 Fractional 값을 반환합니다.
그리고 음의 값은 필요하지 않으므로 첫 번째 단계에서는 1보다 큰 숫자를 선택합니다.
스텝 3: 반환된 값은 -1과 1 사이의 분수 값입니다.
따라서 이 값을 10으로 곱하면 1보다 커집니다.
x = x * 10; // 10 for Single Digit Number
순서 4: 추가 자리수의 값에 10을 곱합니다.
x = x * 10; // Will Give value between 10 and 99 OR
x = x * 100; // Will Give value between 100 and 999
이치노
결과는 10진수입니다.
5단계: 소수점 이후의 값을 수학의 라운드(Math.round) 메서드로 제거합니다.
x = Math.round(x); // This will give Integer Value.
스텝 6: Math.abs 방법으로 음의 값을 양의 값(있는 경우)으로 변환합니다.
x = Math.abs(x); // Convert Negative Values into Positive(if any)
설명 종료.
최종 코드
var seed = 111; // Any Number greater than 1
var digit = 10 // 1 => single digit, 10 => 2 Digits, 100 => 3 Digits and so. (Multiple of 10)
var x; // Initialize the Value to store the result
x = Math.sin(seed); // Perform Mathematical Sin Method on Seed.
x = x * 10; // Convert that number into integer
x = x * digit; // Number of Digits to be included
x = Math.round(x); // Remove Decimals
x = Math.abs(x); // Convert Negative Number into Positive
깨끗하고 최적화된 기능 코드
function random_seed(seed, digit = 1) {
var x = Math.abs(Math.round(Math.sin(seed++) * 10 * digit));
return x;
}
이 를 사용해서요.
random_seed(any_number, number_of_digits)
any_number는 1보다 커야 합니다.
number_of_digits는 옵션 파라미터이며, 아무것도 전달되지 않으면 1자리가 반환됩니다.
random_seed(555); // 1 Digit
random_seed(234, 1); // 1 Digit
random_seed(7895656, 1000); // 4 Digit
0 ~ 100 의 숫자에 대해서.
Number.parseInt(Math.floor(Math.random() * 100))
언급URL : https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript
'programing' 카테고리의 다른 글
| 특정 순서로 PHPUnit 테스트 실행 (0) | 2022.12.27 |
|---|---|
| php의 플로트 비교 (0) | 2022.12.27 |
| MySQL - 일대일 관계 (0) | 2022.12.27 |
| json_encode/json_decode - PHP의 어레이 대신 stdClass를 반환합니다. (0) | 2022.12.27 |
| Hamcrest 비교 컬렉션 (0) | 2022.12.07 |