## Different probability for ranges of random numbers - javascript

I'm looking for the best way of implementing random number generator, that will allow me to have control over probability from what range the generated number will be returned. To visualize what I'm trying to achieve I have a picture :
So to summarize :
Let's say that my range is 400. At the beginning I'd like to have 5% probability of getting number 0-20. But at some moment in time I'd like to have this probability increased up to 50%. Hope you get the idea.

Hmm, working on your original I had a pretty simple algorithm to generate ranges in an array in the appropriate proportion, then randomly select a range and generate a random number within that range. No doubt it can be optimised if necessary, but it works for me.
It looks like a lot of code, but 3/4 of it is comments, test data and function, the actual randomRange function is only 17 lines of code.
<script type="text/javascript">
function randomRange(dataArray) {
// Helper function
function getRandomInRange(s, f) {
return (Math.random() * (f-s+1) | 0) + s
}
// Generate new data array based on probability
var i, j = dataArray.length;
var oArray = [];
var o;
while (j--) {
o = dataArray[j];
// Make sure probability is an integer
for (i=0, iLen=o.probability|0; i<iLen; i++) {
oArray.push([o.rangeStart, o.rangeEnd]);
}
}
// Randomly select a range from new data array and
// generate a random number in that range
var oEnd = oArray.length;
var range = oArray[getRandomInRange(0, oArray.length - 1)];
return getRandomInRange(range[0], range[1]);
}
// Test data set. Probability just has to be
// representative, so 50/50 === 1/1
var dataArray = [
{
rangeStart: 0,
rangeEnd : 20,
probability: 1
},
{
rangeStart: 21,
rangeEnd : 400,
probability: 1
}
];
// Test function to show range and number is randomly
// selected for given probability
function testIt() {
var el0 = document.getElementById('div0');
var el1 = document.getElementById('div1');
function run() {
var n = randomRange(dataArray);
if (n <= 20) {
el0.innerHTML += '*';
} else {
el1.innerHTML += '*';
}
}
setInterval(run, 500);
}
</script>
<button onclick="testIt();">Generate random number</button>
<div>Numbers 0 - 20</div>
<div id="div0"></div>
<div>Numbers 21 - 400</div>
<div id="div1"></div>

It sounds to me like what you're looking for is a way to generate numbers on a normal (or Gaussian) distribution (take a look at the Wikipedia page if you don't know what that means).
The Box-Muller transformation can be used to generate pairs of normally distributed numbers.
Here is a c++ implementation of the polar form of the Box-Muller transformation that shouldn't be hard to translate to javascript.
// Return a real number from a normal (Gaussian) distribution with given
// mean and standard deviation by polar form of Box-Muller transformation
double x, y, r;
do
{
x = 2.0 * rand() - 1.0;
y = 2.0 * rand() - 1.0;
r = x * x + y * y;
}
while ( r >= 1.0 || r == 0.0 );
double s = sqrt( -2.0 * log(r) / r );
return mean + x * s * stddev;
Where mean is the mean of the normal distribution and stddev is the Standard Deviation of the distribution. This code is from a MersesenneTwister C++ class that I've been using recently that you can find on Rick Wagner's page. You can find some more useful information about the Box-Muller transformation on this page.

## Related

### Get a random number focused on center

Is it possible to get a random number between 1-100 and keep the results mainly within the 40-60 range? I mean, it will go out of that range rarely, but I want it to be mainly within that range... Is it possible with JavaScript/jQuery? Right now I'm just using the basic Math.random() * 100 + 1.

The simplest way would be to generate two random numbers from 0-50 and add them together. This gives a distribution biased towards 50, in the same way rolling two dice biases towards 7. In fact, by using a larger number of "dice" (as #Falco suggests), you can make a closer approximation to a bell-curve: function weightedRandom(max, numDice) { let num = 0; for (let i = 0; i < numDice; i++) { num += Math.random() * (max/numDice); } return num; } JSFiddle: http://jsfiddle.net/797qhcza/1/

You have some good answers here that give specific solutions; let me describe for you the general solution. The problem is: I have a source of more-or-less uniformly distributed random numbers between 0 and 1. I wish to produce a sequence of random numbers that follow a different distribution. The general solution to this problem is to work out the quantile function of your desired distribution, and then apply the quantile function to the output of your uniform source. The quantile function is the inverse of the integral of your desired distribution function. The distribution function is the function where the area under a portion of the curve is equal to the probability that the randomly-chosen item will be in that portion. I give an example of how to do so here: http://ericlippert.com/2012/02/21/generating-random-non-uniform-data/ The code in there is in C#, but the principles apply to any language; it should be straightforward to adapt the solution to JavaScript.

Taking arrays of numbers, etc. isn't efficient. You should take a mapping which takes a random number between 0 to 100 and maps to the distribution you need. So in your case, you could take f(x)=-(1/25)x2+4x to get a distribution with the most values in the middle of your range.

I might do something like setup a "chance" for the number to be allowed to go "out of bounds". In this example, a 20% chance the number will be 1-100, otherwise, 40-60: $(function () { $('button').click(function () { var outOfBoundsChance = .2; var num = 0; if (Math.random() <= outOfBoundsChance) { num = getRandomInt(1, 100); } else { num = getRandomInt(40, 60); } $('#out').text(num); }); function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } }); <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> <button>Generate</button> <div id="out"></div> fiddle: http://jsfiddle.net/kbv39s9w/

I needed to solve this problem a few years ago and my solution was easier than any of the other answers. I generated 3 randoms between the bounds and averaged them. This pulls the result towards the centre but leaves it completely possible to reach the extremities.

It looks stupid but you can use rand twice: var choice = Math.random() * 3; var result; if (choice < 2){ result = Math.random() * 20 + 40; //you have 2/3 chance to go there } else { result = Math.random() * 100 + 1; }

Sure it is possible. Make a random 1-100. If the number is <30 then generate number in range 1-100 if not generate in range 40-60.

There is a lot of different ways to generate such random numbers. One way to do it is to compute the sum of multiple uniformly random numbers. How many random numbers you sum and what their range is will determine how the final distribution will look. The more numbers you sum up, the more it will be biased towards the center. Using the sum of 1 random number was already proposed in your question, but as you notice is not biased towards the center of the range. Other answers have propose using the sum of 2 random numbers or the sum of 3 random numbers. You can get even more bias towards the center of the range by taking the sum of more random numbers. At the extreme you could take the sum of 99 random numbers which each were either 0 or 1. That would be a binomial distribution. (Binomial distributions can in some sense be seen as the discrete version of normal distributions). This can still in theory cover the full range, but it has so much bias towards the center that you should never expect to see it reach the endpoints. This approach means you can tweak just how much bias you want.

What about using something like this: var loops = 10; var tries = 10; var div = $("#results").html(random()); function random() { var values = ""; for(var i=0; i < loops; i++) { var numTries = tries; do { var num = Math.floor((Math.random() * 100) + 1); numTries--; } while((num < 40 || num >60) && numTries > 1) values += num + "<br/>"; } return values; } <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> <div id="results"></div> The way I've coded it allows you to set a couple of variables: loops = number of results tries = number of times the function will try to get a number between 40-60 before it stops running through the while loop Added bonus: It uses do while!!! Awesomeness at its best

You can write a function that maps random values between [0, 1) to [1, 100] according to weight. Consider this example: Here, the value 0.95 maps to value between [61, 100]. In fact we have .05 / .1 = 0.5, which, when mapped to [61, 100], yields 81. Here is the function: /* * Function that returns a function that maps random number to value according to map of probability */ function createDistributionFunction(data) { // cache data + some pre-calculations var cache = []; var i; for (i = 0; i < data.length; i++) { cache[i] = {}; cache[i].valueMin = data[i].values[0]; cache[i].valueMax = data[i].values[1]; cache[i].rangeMin = i === 0 ? 0 : cache[i - 1].rangeMax; cache[i].rangeMax = cache[i].rangeMin + data[i].weight; } return function(random) { var value; for (i = 0; i < cache.length; i++) { // this maps random number to the bracket and the value inside that bracket if (cache[i].rangeMin <= random && random < cache[i].rangeMax) { value = (random - cache[i].rangeMin) / (cache[i].rangeMax - cache[i].rangeMin); value *= cache[i].valueMax - cache[i].valueMin + 1; value += cache[i].valueMin; return Math.floor(value); } } }; } /* * Example usage */ var distributionFunction = createDistributionFunction([ { weight: 0.1, values: [1, 40] }, { weight: 0.8, values: [41, 60] }, { weight: 0.1, values: [61, 100] } ]); /* * Test the example and draw results using Google charts API */ function testAndDrawResult() { var counts = []; var i; var value; // run the function in a loop and count the number of occurrences of each value for (i = 0; i < 10000; i++) { value = distributionFunction(Math.random()); counts[value] = (counts[value] || 0) + 1; } // convert results to datatable and display var data = new google.visualization.DataTable(); data.addColumn("number", "Value"); data.addColumn("number", "Count"); for (value = 0; value < counts.length; value++) { if (counts[value] !== undefined) { data.addRow([value, counts[value]]); } } var chart = new google.visualization.ColumnChart(document.getElementById("chart")); chart.draw(data); } google.load("visualization", "1", { packages: ["corechart"] }); google.setOnLoadCallback(testAndDrawResult); <script src="https://www.google.com/jsapi"></script> <div id="chart"></div>

Here's a weighted solution at 3/4 40-60 and 1/4 outside that range. function weighted() { var w = 4; // number 1 to w var r = Math.floor(Math.random() * w) + 1; if (r === 1) { // 1/w goes to outside 40-60 var n = Math.floor(Math.random() * 80) + 1; if (n >= 40 && n <= 60) n += 40; return n } // w-1/w goes to 40-60 range. return Math.floor(Math.random() * 21) + 40; } function test() { var counts = []; for (var i = 0; i < 2000; i++) { var n = weighted(); if (!counts[n]) counts[n] = 0; counts[n] ++; } var output = document.getElementById('output'); var o = ""; for (var i = 1; i <= 100; i++) { o += i + " - " + (counts[i] | 0) + "\n"; } output.innerHTML = o; } test(); <pre id="output"></pre>

Ok, so I decided to add another answer because I felt like my last answer, as well as most answers here, use some sort of half-statistical way of obtaining a bell-curve type result return. The code I provide below works the same way as when you roll a dice. Therefore, it is hardest to get 1 or 99, but easiest to get 50. var loops = 10; //Number of numbers generated var min = 1, max = 50; var div = $("#results").html(random()); function random() { var values = ""; for (var i = 0; i < loops; i++) { var one = generate(); var two = generate(); var ans = one + two - 1; var num = values += ans + "<br/>"; } return values; } function generate() { return Math.floor((Math.random() * (max - min + 1)) + min); } <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script> <div id="results"></div>

I'd recommend using the beta distribution to generate a number between 0-1, then scale it up. It's quite flexible and can create many different shapes of distributions. Here's a quick and dirty sampler: rbeta = function(alpha, beta) { var a = 0 for(var i = 0; i < alpha; i++) a -= Math.log(Math.random()) var b = 0 for(var i = 0; i < beta; i++) b -= Math.log(Math.random()) return Math.ceil(100 * a / (a+b)) }

var randNum; // generate random number from 1-5 var freq = Math.floor(Math.random() * (6 - 1) + 1); // focus on 40-60 if the number is odd (1,3, or 5) // this should happen %60 of the time if (freq % 2){ randNum = Math.floor(Math.random() * (60 - 40) + 40); } else { randNum = Math.floor(Math.random() * (100 - 1) + 1); }

The best solution targeting this very problem is the one proposed by BlueRaja - Danny Pflughoeft but I think a somewhat faster and more general solution is also worth mentioning. When I have to generate random numbers (strings, coordinate pairs, etc.) satisfying the two requirements of The result set is quite small. (not larger than 16K numbers) The result set is discreet. (like integer numbers only) I usually start by creating an array of numbers (strings, coordinate pairs, etc.) fulfilling the requirement (In your case: an array of numbers containing the more probable ones multiple times.), then choose a random item of that array. This way, you only have to call the expensive random function once per item.

Distribution 5% for [ 0,39] 90% for [40,59] 5% for [60,99] Solution var f = Math.random(); if (f < 0.05) return random(0,39); else if (f < 0.95) return random(40,59); else return random(60,99); Generic Solution random_choose([series(0,39),series(40,59),series(60,99)],[0.05,0.90,0.05]); function random_choose (collections,probabilities) { var acc = 0.00; var r1 = Math.random(); var r2 = Math.random(); for (var i = 0; i < probabilities.length; i++) { acc += probabilities[i]; if (r1 < acc) return collections[i][Math.floor(r2*collections[i].length)]; } return (-1); } function series(min,max) { var i = min; var s = []; while (s[s.length-1] < max) s[s.length]=i++; return s; }

You can use a helper random number to whether generate random numbers in 40-60 or 1-100: // 90% of random numbers should be between 40 to 60. var weight_percentage = 90; var focuse_on_center = ( (Math.random() * 100) < weight_percentage ); if(focuse_on_center) { // generate a random number within the 40-60 range. alert (40 + Math.random() * 20 + 1); } else { // generate a random number within the 1-100 range. alert (Math.random() * 100 + 1); }

If you can use the gaussian function, use it. This function returns normal number with average 0 and sigma 1. 95% of this number are within average +/- 2*sigma. Your average = 50, and sigma = 5 so randomNumber = 50 + 5*gaussian()

The best way to do that is generating a random number that is distributed equally in a certain set of numbers, and then apply a projection function to the set between 0 and a 100 where the projection is more likely to hit the numbers you want. Typically the mathematical way of achieving this is plotting a probability function of the numbers you want. We could use the bell curve, but let's for the sake of easier calculation just work with a flipped parabola. Let's make a parabola such that its roots are at 0 and 100 without skewing it. We get the following equation: f(x) = -(x-0)(x-100) = -x * (x-100) = -x^2 + 100x Now, all the area under the curve between 0 and 100 is representative of our first set where we want the numbers generated. There, the generation is completely random. So, all we need to do is find the bounds of our first set. The lower bound is, of course, 0. The upper bound is the integral of our function at 100, which is F(x) = -x^3/3 + 50x^2 F(100) = 500,000/3 = 166,666.66666 (let's just use 166,666, because rounding up would make the target out of bounds) So we know that we need to generate a number somewhere between 0 and 166,666. Then, we simply need to take that number and project it to our second set, which is between 0 and 100. We know that the random number we generated is some integral of our parabola with an input x between 0 and 100. That means that we simply have to assume that the random number is the result of F(x), and solve for x. In this case, F(x) is a cubic equation, and in the form F(x) = ax^3 + bx^2 + cx + d = 0, the following statements are true: a = -1/3 b = 50 c = 0 d = -1 * (your random number) Solving this for x yields you the actual random number your are looking for, which is guaranteed to be in the [0, 100] range and a much higher likelihood to be close to the center than the edges.

This answer is really good. But I would like to post implementation instructions (I'm not into JavaScript, so I hope you will understand) for different situation. Assume you have ranges and weights for every range: ranges - [1, 20], [21, 40], [41, 60], [61, 100] weights - {1, 2, 100, 5} Initial Static Information, could be cached: Sum of all weights (108 in sample) Range selection boundaries. It basically this formula: Boundary[n] = Boundary[n - 1] + weigh[n - 1] and Boundary[0] = 0. Sample has Boundary = {0, 1, 3, 103, 108} Number generation: Generate random number N from range [0, Sum of all weights). for (i = 0; i < size(Boundary) && N > Boundary[i + 1]; ++i) Take ith range and generate random number in that range. Additional note for performance optimizations. Ranges don't have to be ordered neither ascending nor descending order, so for faster range look-up range that has highest weight should go first and one with lowest weight should go last.

### JavaScript Math.random Normal distribution (Gaussian bell curve)?

I want to know if the JavaScript function Math.random uses a normal (vs. uniform) distribution or not. If not, how can I get numbers which use a normal distribution? I haven't found a clear answer on the Internet, for an algorithm to create random normally-distributed numbers. I want to rebuild a Schmidt-machine (German physicist). The machine produces random numbers of 0 or 1, and they have to be normally-distributed so that I can draw them as a Gaussian bell curve. For example, the random function produces 120 numbers (0 or 1) and the average (mean) of these summed values has to be near 60.

Since this is the first Google result for "js gaussian random" in my experience, I feel an obligation to give an actual answer to that query. The Box-Muller transform converts two independent uniform variates on (0, 1) into two standard Gaussian variates (mean 0, variance 1). This probably isn't very performant because of the sqrt, log, and cos calls, but this method is superior to the central limit theorem approaches (summing N uniform variates) because it doesn't restrict the output to the bounded range (-N/2, N/2). It's also really simple: // Standard Normal variate using Box-Muller transform. function gaussianRandom(mean=0, stdev=1) { let u = 1 - Math.random(); //Converting [0,1) to (0,1) let v = Math.random(); let z = Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v ); // Transform to the desired mean and standard deviation: return z * stdev + mean; }

Normal Distribution Between 0 and 1 Building on Maxwell's Answer, this code uses the Box–Muller transform to give you a normal distribution between 0 and 1 inclusive. It just resamples the values if it's more than 3.6 standard deviations away (less than 0.02% chance). function randn_bm() { let u = 0, v = 0; while(u === 0) u = Math.random(); //Converting [0,1) to (0,1) while(v === 0) v = Math.random(); let num = Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v ); num = num / 10.0 + 0.5; // Translate to 0 -> 1 if (num > 1 || num < 0) return randn_bm() // resample between 0 and 1 return num } Visualizations n = 100 n = 10,000 n = 10,000,000 Normal Distribution With Min, Max, Skew This version allows you to give a min, max, and skew factor. See my usage examples at the bottom. function randn_bm(min, max, skew) { let u = 0, v = 0; while(u === 0) u = Math.random() //Converting [0,1) to (0,1) while(v === 0) v = Math.random() let num = Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v ) num = num / 10.0 + 0.5 // Translate to 0 -> 1 if (num > 1 || num < 0) num = randn_bm(min, max, skew) // resample between 0 and 1 if out of range else{ num = Math.pow(num, skew) // Skew num *= max - min // Stretch to fill range num += min // offset to min } return num } randn_bm(-500, 1000, 1); randn_bm(10, 20, 0.25); randn_bm(10, 20, 3); Here is the JSFiddle for these screenshots: https://jsfiddle.net/2uc346hp/

I want to know if the JavaScript function Math.random is normal distribution or not Javascript Math.random is not a Normal Distribution(Gaussian bell curve). From ES 2015, 20.2.2.27 "Returns a Number value with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-dependent algorithm or strategy. This function takes no arguments." So the provided collection when n is high enough we will get approximately uniform distribution. All values in the interval will have equal probability of appearance(straight line parallel to the x axis, denoting number between 0.0 and 1.0). how can I get numbers which are normal distribution There are several ways of getting collection of numbers with a normal distribution. As answered by Maxwell Collard the Box-Muller transform does transform uniform distribution to normal distribution(the code can be found in Maxwell Collard answer). An answer to another stackoverflow answer to a question has a reply with other uniform distribution to normal distribution algorithms. Such as: Ziggurat, Ratio-of-uniforms, Inverting the CDF Besides one of the answers says that: says: The Ziggurat algorithm is pretty efficient for this, although the Box-Muller transform is easier to implement from scratch (and not crazy slow). And finally I want to rebuilt a Schmidt-machine (German physicist), the machine produces random numbers of 0 or 1 and they have to be normal distributed so I can draw them in Gaussian bell curve. When we have only two values (0 or 1) Gaussian curve looks the same as uniform distribution with 2 possible values. That is why a simple function randomZero_One(){ return Math.round(Math.random()); } would suffice. It would return pseudo-randomly with approximately equal probability values 0 and 1.

I wanted to have approximately gaussian random numbers between 0 and 1, and after many tests I found this to be the best: function gaussianRand() { var rand = 0; for (var i = 0; i < 6; i += 1) { rand += Math.random(); } return rand / 6; } And as a bonus: function gaussianRandom(start, end) { return Math.floor(start + gaussianRand() * (end - start + 1)); }

The Javascript Math.random() pseudorandom function returns variates that are equally distributed between 0 and 1. To get a Gaussian distribution I use this: // returns a gaussian random function with the given mean and stdev. function gaussian(mean, stdev) { var y2; var use_last = false; return function() { var y1; if (use_last) { y1 = y2; use_last = false; } else { var x1, x2, w; do { x1 = 2.0 * Math.random() - 1.0; x2 = 2.0 * Math.random() - 1.0; w = x1 * x1 + x2 * x2; } while (w >= 1.0); w = Math.sqrt((-2.0 * Math.log(w)) / w); y1 = x1 * w; y2 = x2 * w; use_last = true; } var retval = mean + stdev * y1; if (retval > 0) return retval; return -retval; } } // make a standard gaussian variable. var standard = gaussian(100, 15); // make a bunch of standard variates for (i = 0; i < 1000; i++) { console.log( standard() ) } I think I got this from Knuth. Plot can be seen here

Function that utilises the central limit theorem. function normal(mu, sigma, nsamples){ if(!nsamples) nsamples = 6 if(!sigma) sigma = 1 if(!mu) mu=0 var run_total = 0 for(var i=0 ; i<nsamples ; i++){ run_total += Math.random() } return sigma*(run_total - nsamples/2)/(nsamples/2) + mu }

From the spec: 15.8.2.14 random ( ) Returns a Number value with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an implementation-dependent algorithm or strategy. This function takes no arguments. So, it's a uniform distribution, not normal or Gaussian. That's what you're going to find in just about any standard random number facility in any basic language runtime outside of specialized statistics libraries.

You are confusing the output of the function (which is a uniform distribution between 0 and 1) with the need to generate a Gaussian distribution by repeatedly drawing random numbers that are either 0 or 1 - after a large number of trials, their sum will be approximately normally distributed. You can use the Math.random() function, then round the result to an integer: if it's < 0.5, return 0; if its >= 0.5, return 1. Now you have equal probabilities of zero and one, and you can continue with the approach you described in your question. Just to clarify: I don't think it's possible to have an algorithm that produces either 0's or 1's in a normally distributed way - normal distribution requires a continuous variable. When you do the above for say 120 numbers, you will on average get 60 1's and 60 0's. The actual distribution you get will be the binomial distribution with a mean of 60 and a standard deviation of stdev = sqrt(p(1-p)N) = 5.48 The probability of a particular number k when you have n samples with probability p (which we fixed at 0.5) is p = n! / ((n-k)! k!) p^k (1-p)^(n-k) When p = 0.5, you end up with just the binomial coefficients - which approach the normal distribution for n > 30, typically.

And a single line example: Math.sqrt(-2 * Math.log(Math.random()))*Math.cos((2*Math.PI) * Math.random()) and a Fiddle https://jsfiddle.net/rszgjqf8/

For those interested in generating values of a normal distrubution, I would recommend checking this implementation of the Ziggurat algorithm in JavaScript: https://www.npmjs.com/package/node-ziggurat The code of found in the author's page is: function Ziggurat(){ var jsr = 123456789; var wn = Array(128); var fn = Array(128); var kn = Array(128); function RNOR(){ var hz = SHR3(); var iz = hz & 127; return (Math.abs(hz) < kn[iz]) ? hz * wn[iz] : nfix(hz, iz); } this.nextGaussian = function(){ return RNOR(); } function nfix(hz, iz){ var r = 3.442619855899; var r1 = 1.0 / r; var x; var y; while(true){ x = hz * wn[iz]; if( iz == 0 ){ x = (-Math.log(UNI()) * r1); y = -Math.log(UNI()); while( y + y < x * x){ x = (-Math.log(UNI()) * r1); y = -Math.log(UNI()); } return ( hz > 0 ) ? r+x : -r-x; } if( fn[iz] + UNI() * (fn[iz-1] - fn[iz]) < Math.exp(-0.5 * x * x) ){ return x; } hz = SHR3(); iz = hz & 127; if( Math.abs(hz) < kn[iz]){ return (hz * wn[iz]); } } } function SHR3(){ var jz = jsr; var jzr = jsr; jzr ^= (jzr << 13); jzr ^= (jzr >>> 17); jzr ^= (jzr << 5); jsr = jzr; return (jz+jzr) | 0; } function UNI(){ return 0.5 * (1 + SHR3() / -Math.pow(2,31)); } function zigset(){ // seed generator based on current time jsr ^= new Date().getTime(); var m1 = 2147483648.0; var dn = 3.442619855899; var tn = dn; var vn = 9.91256303526217e-3; var q = vn / Math.exp(-0.5 * dn * dn); kn[0] = Math.floor((dn/q)*m1); kn[1] = 0; wn[0] = q / m1; wn[127] = dn / m1; fn[0] = 1.0; fn[127] = Math.exp(-0.5 * dn * dn); for(var i = 126; i >= 1; i--){ dn = Math.sqrt(-2.0 * Math.log( vn / dn + Math.exp( -0.5 * dn * dn))); kn[i+1] = Math.floor((dn/tn)*m1); tn = dn; fn[i] = Math.exp(-0.5 * dn * dn); wn[i] = dn / m1; } } zigset(); } Create a Ziggurat.js file and then: var z = new Ziggurat(); z.nextGaussian(); For me it's working just perfect and as I had read in Wikipedia, this is a more efficient algorithm than the Box-Muller. enter link description here

I have tested several functions with the right configuration all work similarly and well. http://jsfiddle.net/p3y40gf3/29/ Central limit is nice, must be with (n=3 for 6) and 12 for 12 to look as others. I configured others also to (6) or 12 or 1/12 as standard deviation, not sure why 12. Central limit is a tiny bit less centered than Box/Muller and Ziggurat. Box/Muller and Ziggurat look exactly the same this variant by Joe(https://stackoverflow.com/a/33567961/466363) does standard deviation correctly: function normal(mu, sigma, nsamples){ // using central limit if(!nsamples) nsamples = 3 if(!sigma) sigma = 1 if(!mu) mu=0 var run_total = 0 for(var i=0 ; i<nsamples ; i++){ run_total += Math.random() } return sigma*(run_total - nsamples/2)/(nsamples/2) + mu } Ziggurat is also nice but needs to be adjusted from z score to from 0 to 1 looks like it makes good numbers. Box/Muller clipped is good but gives few repeated numbers at clipped edges but it is very similar to others, incorrect random numbers should be discarded not clipped. function randn_bm() { var u = 0, v = 0; while(u === 0) u = Math.random(); //Converting [0,1) to (0,1) while(v === 0) v = Math.random(); let num = Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v ); num = num / 6.0 + 0.5; // Translate to 0 -> 1 // changed here 10 to 6 if(num>1||num<0) return randn_bm(); return num; // bad random numbers should be discared not clipped //return Math.max(Math.min(num, 1), 0); // cap between 0 and 1 } Central limit variant it is called Bates distribution that is average https://en.wikipedia.org/wiki/Bates_distribution not confused with Irwin Hall that is a sum https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution https://en.wikipedia.org/wiki/Normal_distribution#Generating_values_from_normal_distribution

A non verbose function to sample a random value from a Gaussian distribution I wrote some time ago: function gaussianRandom(mean, sigma) { let u = Math.random()*0.682; return ((u % 1e-8 > 5e-9 ? 1 : -1) * (Math.sqrt(-Math.log(Math.max(1e-9, u)))-0.618))*1.618 * sigma + mean; } It should work if you clamp the values to the range you want.

skewnormal from normal and normal01 skewnormal(min, max, ..) returns a random number from the normal distribution that has been streched and offset to range from min to max, exponentially skewed with skew, and truncated to sigma standard deviations (in reverse order). Broken up into logical steps normal and normal01 for clarity and to generate random numbers directly from these intermediate functions if desired. (Plus a bonus lognormal!) /// skewnormal(..) returns a random number from the normal distribution that has /// been streched and offset to range from `min` to `max`, skewed with `skew`, /// and truncated to `sigma` standard deviations. See https://stackoverflow.com/a/74258559/213246 const skewnormal = (min, max, skew = 1, sigma = 8) => { /// normal() returns a random number from the standard normal distribution. /// Uses the Box-Muller transform. const normal = () => Math.sqrt(-2.0 * Math.log(Math.random())) * Math.cos(2.0 * Math.PI * Math.random()); /// normal01(..) returns normally distributed random number, whose range is /// truncated at `sigma` standard deviations and shifted to interval `[0, 1]`. const normal01 = (sigma) => { while (true) { let num = normal() / (sigma + 0.0) + 0.5; // translate to [0, 1] if (0 <= num && num <= 1) return num; // ok if in range, else resample } } var num = normal01(sigma); num = Math.pow(num, skew) // skew num *= max - min // stretch to fill range num += min // offset to min return num; } /// lognormal() returns a random number from the log-normal distribution. const lognormal = () => Math.exp(normal()); Based on another popular answer by joshuakcockrell. You may prefer this implementation because: 1. it's factored to portray intermediate functions, 2. it exposes mathematically relevant and useful sigma parameter, 3. it has better names and comments. See the JSFiddle for the complete demo environment, which makes it easy to define then test and visualize your own random distribution functions as pictured below: View interactive charts: https://jsfiddle.net/rgefzusq/34/show/ Playground: https://jsfiddle.net/rgefzusq/34/

This is my JavaScript implementation of Algorithm P (Polar method for normal deviates) from Section 3.4.1 of Donald Knuth's book The Art of Computer Programming: function gaussian(mean, stddev) { return function() { var V1 var V2 var S do{ var U1 = Math.random() var U2 = Math.random() V1 = 2*U1-1 V2 = 2*U2-1 S = V1*V1+V2*V2 }while(S >= 1) if(S===0) return 0 return mean+stddev*(V1*Math.sqrt(-2*Math.log(S)/S)) } } Use it like that: var standard_normal = gaussian(0,1) var a_standard_normal_deviate = standard_normal()

I found this library that includes lots of useful Random functions. You can either install it via simjs from npm, or just take the random-node-*.js file out directly for what you need. http://www.simjs.com/random.html http://www.simjs.com/download.html

This is my solution to the problem, using the Marsaglia polar method. The range depends on the parameters you give, without parameters it almost never generates anything outside of the range. As it generates two normally distributed numbers per iteration, I declared a variable under window.temp.spareNormal to grab the spare one if it's there. Might not be the best location for it, but hey. You'd probably have to round the result in order to get what you want. window.temp = { spareNormal: undefined }; Math.normal = function (mean, standardDeviation) { let q, u, v, p; mean = mean || 0.5; standardDeviation = standardDeviation || 0.125; if (typeof temp.spareNormal !== 'undefined') { v = mean + standardDeviation * temp.spareNormal; temp.spareNormal = undefined; return v; } do { u = 2.0 * Math.random() - 1.0; v = 2.0 * Math.random() - 1.0; q = u * u + v * v; } while (q >= 1.0 || q === 0); p = Math.sqrt(-2.0 * Math.log(q) / q); temp.spareNormal = v * p; return mean + standardDeviation * u * p; }

for finding normal distribution of value: getNormal = (x, mean, standardDeviation, ) => { return (1 / standardDeviation * Math.sqrt(2 * (3, 14))) * Math.pow(Math.E, -Math.pow(x - mean, 2) / (2 * (standardDeviation * standardDeviation))); }

The only sort of qualifications I have for this is having taken a single statistics class. If I get something wrong, please tell me, I'd like to learn more about statistics and I don't want to keep thinking something wrong. If you want to create a random number generator that produces numbers in a normal distribution, you should be able to take samples from a uniform distribution, which is no problem. If you set up a basic random number generator that generates numbers in range a to b, the distribution of values produced will have µ = (a+b)/2 and σ = (b-a)/√12. If the mean of a a few sample of values (≥30) taken from this distribution is taken for many such samples, then for the sampling distribution µ (sample means) = µ (population mean) and σ (sample means' stdev) = σ (population stdev)/√n (number of values in the sample). By controlling the mean and stdev of the original distribution, you can control the ending mean and standard deviation of a random number generator that produces a normal distribution. function all_normal(mu, sigma, nsamp) { var total = 0; for (var a = 0; a < nsamp; a ++) { total += rand_int(mu - (sigma * Math.sqrt(3 * nsamp)), mu + (sigma * Math.sqrt(3 * nsamp))); } return Math.ceil(total / nsamp); }

Just in case: Math.pow(Math.random(), p). For example: function testR(max = 100, min = 0, p = 1, c = 20) { let t = []; for (let i = 0; i < c; ++i) { t.push(Math.floor(Math.pow(Math.random(), p) * (max - min + 1) + min)); } console.log( `p = ${String(p).padStart(5)}`, '|', t.sort(function (a, b) { return a - b; }).join(', ') ); } testR(9, 0, 10); testR(9, 0, 2); testR(9, 0, 1); testR(9, 0, 0.5); testR(9, 0, 0.1); testR(9, 0, 0.05); Results in client/JS console jsFiddle graph test:

let iset = 0; let gset; function randn() { let v1, v2, fac, rsq; if (iset == 0) { do { v1 = 2.0*Math.random() - 1.0; v2 = 2.0*Math.random() - 1.0; rsq = v1*v1+v2*v2; } while ((rsq >= 1.0) || (rsq == 0)); fac = Math.sqrt(-2.0*Math.log(rsq)/rsq); gset = v1*fac; iset = 1; return v2*fac; } else { iset = 0; return gset; } }

//This is what I use for a Normal-ish distribution random function. function normal_random(){ var pos = [ Math.random(), Math.random() ]; while ( Math.sin( pos[0] * Math.PI ) > pos[1] ){ pos = [ Math.random(), Math.random() ]; } return pos[0]; }; This function returns a value between 0 and 1. Values near 0.5 are returned most often.

### reordering objects without impacting other objects

I have a list of items (think, files in a directory), where the order of these items is arbitrarily managed by a user. The user can insert an item between other items, delete items, and move them around. What is the best way to store the ordering as a property of each item so that when a specific item is inserted or moved, the ordering property of the other items is not affected? These objects will be stored in a database. An ideal implementation would be able to support inifinite number of insertions/reorders. The test I'm using to identify the limitations of the approach are as follows: With 3 items x,y,z, repeatedly take the item on the left and put it between the other two; then take the object on the right and put it between the other two; keep going until some constraint is violated. For others' reference, I have included some algorithms I have tried.

1.1. Decimals, double-precision Store the order as a decimal. To insert an between two items with orders x and y, calculate its order as x/2+y/2. Limitations: Precision, or performance. Using doubles, when the denominator becomes too big, we end up with x/2+y/2==x . In Javascript, it can only handle 25 shuffles. function doubles(x,y,z) { for (var i = 0; i < 10000000; i++) { //x,y,z //x->v1: y,v1,z //z->v2: y,v2,v1 var v1 = y/2 + z/2 var v2 = y/2 + v1/2 x = y y = v2 z = v1 if (x == y) { console.log(i) break } } } >doubles(1, 1.5, 2) >25 1.2. Decimals, BigDecimal The same as above, but using BigDecimal from https://github.com/iriscouch/bigdecimal.js. In my test, the performance degraded unusably quickly. It might be a good choice for other frameworks, but not for client-side javascript. I threw that implementation away and don't have it anymore. 2.1. Fractions Store the order as a (numerator, denominator) integer tuple. To insert an item between items xN/xD and yN/yD, give it a value of (xN+yN)/(xD+yD) (which can easily be shown to be between the other two numbers). Limitations: precision or overflow. function fractions(xN, xD, yN, yD, zN, zD){ for (var i = 0; i < 10000000; i++) { //x,y,z //x->v1: y,v1,z //z->v2: y,v2,v1 var v1N = yN + zN, v1D = yD + zD var v2N = yN + v1N, v2D = yD + v1D xN = yN, xD=yD yN = v2N, yD=v2D zN = v1N, zd=v1D if (!isFinite(xN) || !isFinite(xD)) { // overflow console.log(i) break } if (xN/xD == yN/yD) { //precision console.log(i) break } } } >fractions(1,1,3,2,2,1) >737 2.2. Fractions with GCD reduction The same as above, but reduce fractions using a Greatest Common Denomenator algorithm: function gcd(x, y) { if(!isFinite(x) || !isFinite(y)) { return NaN } while (y != 0) { var z = x % y; x = y; y = z; } return x; } function fractionsGCD(xN, xD, yN, yD, zN, zD) { for (var i = 0; i < 10000000; i++) { //x,y,z //x->v1: y,v1,z //z->v2: y,v2,v1 var v1N = yN + zN, v1D = yD + zD var v2N = yN + v1N, v2D = yD + v1D var v1gcd=gcd(v1N, v1D) var v2gcd=gcd(v2N, v2D) xN = yN, xD = yD yN = v2N/v2gcd, yD=v2D/v2gcd zN = v1N/v1gcd, zd=v1D/v1gcd if (!isFinite(xN) || !isFinite(xD)) { // overflow console.log(i) break } if (xN/xD == yN/yD) { //precision console.log(i) break } } } >fractionsGCD(1,1,3,2,2,1) >6795 3. Alphabetic Use alphabetic ordering. The idea is to start with an alphabet (say, ascii printable range of [32..126]), and grow the strings. So, ('O' being the middle of our range), to insert between "a" and "c", use "b", to insert between "a" and "b", use "aO", and so forth. Limitations: The strings would get so long as to not fit in a database. function middle(low, high) { for(var i = 0; i < high.length; i++) { if (i == low.length) { //aa vs aaf lowcode=32 hicode = high.charCodeAt(i) return low + String.fromCharCode( (hicode - lowcode) / 2) } lowcode = low.charCodeAt(i) hicode = high.charCodeAt(i) if(lowcode==hicode) { continue } else if(hicode - lowcode == 1) { // aa vs ab return low + 'O'; } else { // aa vs aq return low.slice(0,i) + String.fromCharCode(lowcode + (hicode - lowcode) / 2) } } } function alpha(x,y,z, N) { for (var i = 0; i < 10000; i++) { //x,y,z //x->v1: y,v1,z //z->v2: y,v2,v1 var v1 = middle(y, z) var v2 = middle(y, v1) x = y y = v2 z = v1 if(x.length > N) { console.log(i) break } } } >alpha('?', 'O', '_', 256) 1023 >alpha('?', 'O', '_', 512) 2047

Perhaps I have missed something fundamental and I will admit I know little enough about javascript, but surely you can just implement a doubly-linked list to deal with this? Then re-ordering a,b,c,d,e,f,g,h to insert X between d and e you just unlink d->e, link d->X and then link X->e and so on. Because in any of the scenarios above, either you will run out of precision (and your infinite ordering is lost) or you'll end up with very long sort identifiers and no memory :)

Software axiom #1: KEEP IT SIMPLE until you have found a compelling, real and proven reason to make it more complicated. So, I'd argue that it's extra and unnecessary code and maintenance to maintain your own order property when the DOM is already doing it for you. Why not just let the DOM maintain the order and you can dynamically generate a set of brain-dead simple sequence numbers for the current ordering any time you need it? CPUs are plenty fast to generate new sequence numbers for all items anytime you need it or anytime it changes. And, if you want to save this new ordering on the server, just send the whole sequence to the server. Implementing one of these splitting sequences so you can always insert more objects without ever renumbering anything is going to be a lot of code and a lot of opportunities for bugs. You should not go there until it's been proven that you really need that level of complication.

Store the items in an array, and use splice() to insert and delete elements. Or is this not acceptable because of the comment you made in response to the linked list answer?

The problem you are trying to solve is potentially insertion sort which has a simple implementation of O(n^2). But there are ways to improve it. Suppose there is an order variable associated to each element. You can assign these orders smartly with large gaps between variables and get an amortized O(n*log(n)) mechanism. Look at (Insertion sort is nlogn)

### How to generate skewed random numbers in Javascript?

Using Javascript, how can I generate random numbers that are skewed towards one end or the other of the distribution? Or ideally an point within the range? For context: I'm creating a UI that has uses a grid of random grey squares. I'm generating the grey's RGB values using Math.random() but would like to be able to skew the greys to be on average darker or lighter while still having the full range from black to white represented. (I think this is a similar question to Skewing java random number generation toward a certain number but I'm working with Javascript...) Any help greatly appreciated.

Raise Math.random() to a power to get a gamma curve - this changes the distribution between 0 and 1, but 0 and 1 stay constant endpoints. var r= Math.pow(Math.random(), 2); var colour= 'rgb('+r*255+', '+r*255+', '+r*255+')'; For gamma>1, you will get darker output; for 0<gamma<1 you get lighter. (Here, '2' gives you the x-squared curve; the equidistant lightness would be '0.5' for the square-root curve.)

This seems a little crude and less graceful than #bobince's answer, but what the hell. //setup var colours = [], num_colours = 10, skew_to = 255, skew_chance = 20; //get as many RGB vals as required for (var i=0; i<num_colours; i++) { //generate random grey var this_grey = Math.floor(Math.random() * 256); //skew it towards the #skew_to endpoint, or leave as-is? if (Math.floor(Math.random() * 100) >= skew_chance && this_grey != skew_to) { //skew by random amount (0 - difference between curr val and endpoint) var skew_amount = Math.floor(Math.random() * Math.abs(this_grey - skew_to)); this_grey += ' (skewed to '+(skew_to < this_grey ? this_grey - skew_amount : this_grey + skew_amount)+')'; } colours.push(this_grey); } console.log(colours); Essentially it generates random greys then decides, based on probably specified (as a percentage) in skew_chance, whether to skew it or not. (In case you wanted to make this occasional, not constant). If it decides to skew, a random number is then added or subtracted from the grey value (depending on whether the skew endpoint is under or above the current value). This random number is a number between 0 and the absolute difference between the current value and the endpoint, e.g. if current value is 40, and the endpoint is 100, the number added would be between 0 and 60. Like I say, #bobince's answer is somewhat, er, more graceful!

[This might be a little different approach.] This approach deals with getting the number in the following fashion: random = numberToSkewTo + random(-1,1)*stdDeviation Where: numberToSkewTo is the number you want to skew towards. stdDeviation is the deviation from numberToSkewTo numberToSkewTo + abs(stdDeviation) <= MAX_NUMBER and numberToSkewTo - abs(stdDeviation) >= MIN_NUMBER What the following code does is, it pick a random number around the given number with constantly increasing standard deviations. It returns the average of results. function skew(skewTo,stdDev){ var rand = (Math.random()*2 - 1) + (Math.random()*2 - 1) + (Math.random()*2 - 1); return skewTo + rand*stdDev; } function getRandom(skewTo){ var difference = Math.min(skewTo-MIN_NUMBER, MAX_NUMBER-skewTo); var steps = 5; var total = 0.0; for(var i=1; i<=steps; i++) total += skew(skewTo, 1.0*i*difference/steps); return total/steps }

### Seedable JavaScript random number generator

The JavaScript Math.random() function returns a random value between 0 and 1, automatically seeded based on the current time (similar to Java I believe). However, I don't think there's any way to set you own seed for it. How can I make a random number generator that I can provide my own seed value for, so that I can have it produce a repeatable sequence of (pseudo)random numbers?

One option is http://davidbau.com/seedrandom which is a seedable RC4-based Math.random() drop-in replacement with nice properties.

If you don't need the seeding capability just use Math.random() and build helper functions around it (eg. randRange(start, end)). I'm not sure what RNG you're using, but it's best to know and document it so you're aware of its characteristics and limitations. Like Starkii said, Mersenne Twister is a good PRNG, but it isn't easy to implement. If you want to do it yourself try implementing a LCG - it's very easy, has decent randomness qualities (not as good as Mersenne Twister), and you can use some of the popular constants. EDIT: consider the great options at this answer for short seedable RNG implementations, including an LCG option. 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));

If you want to be able to specify the seed, you just need to replace the calls to getSeconds() and getMinutes(). You could pass in an int and use half of it mod 60 for the seconds value and the other half modulo 60 to give you the other part. That being said, this method looks like garbage. Doing proper random number generation is very hard. The obvious problem with this is that the random number seed is based on seconds and minutes. To guess the seed and recreate your stream of random numbers only requires trying 3600 different second and minute combinations. It also means that there are only 3600 different possible seeds. This is correctable, but I'd be suspicious of this RNG from the start. If you want to use a better RNG, try the Mersenne Twister. It is a well tested and fairly robust RNG with a huge orbit and excellent performance. EDIT: I really should be correct and refer to this as a Pseudo Random Number Generator or PRNG. "Anyone who uses arithmetic methods to produce random numbers is in a state of sin." --- John von Neumann

I use a JavaScript port of the Mersenne Twister: https://gist.github.com/300494 It allows you to set the seed manually. Also, as mentioned in other answers, the Mersenne Twister is a really good PRNG.

The code you listed kind of looks like a Lehmer RNG. If this is the case, then 2147483647 is the largest 32-bit signed integer, 2147483647 is the largest 32-bit prime, and 48271 is a full-period multiplier that is used to generate the numbers. If this is true, you could modify RandomNumberGenerator to take in an extra parameter seed, and then set this.seed to seed; but you'd have to be careful to make sure the seed would result in a good distribution of random numbers (Lehmer can be weird like that) -- but most seeds will be fine.

The following is a PRNG that may be fed a custom seed. Calling SeedRandom will return a random generator function. SeedRandom can be called with no arguments in order to seed the returned random function with the current time, or it can be called with either 1 or 2 non-negative inters as arguments in order to seed it with those integers. Due to float point accuracy seeding with only 1 value will only allow the generator to be initiated to one of 2^53 different states. The returned random generator function takes 1 integer argument named limit, the limit must be in the range 1 to 4294965886, the function will return a number in the range 0 to 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 } Example use: 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. This generator exhibit the following properties: It has approximately 2^64 different possible inner states. It has a period of approximately 2^63, plenty more than anyone will ever realistically need in a JavaScript program. Due to the mod values being primes there is no simple pattern in the output, no matter the chosen limit. This is unlike some simpler PRNGs that exhibit some quite systematic patterns. It discards some results in order to get a perfect distribution no matter the limit. It is relatively slow, runs around 10 000 000 times per second on my machine. Bonus: typescript version

If you program in Typescript, I adapted the Mersenne Twister implementation that was brought in Christoph Henkelmann's answer to this thread as a typescript class: /** * 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); } } you can than use it as follows: 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] check the source for more methods.

Here is quite an effective but simple javascript PRNG function that I like to use: // 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 } I hope this is what you're looking for.

Thank you, #aaaaaaaaaaaa (Accepted Answer) I really needed a good non-library solution (easier to embed) so... i made this class to store the seed and allow a Unity-esque "Next" ... but kept the initial Integer based results 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; } } And then checked it with these... seems to work well with random (but queryable) seed value (a la Minecraft) and even stored the last value returned (if needed) 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); which should output (for everybody) 6 7 8 14 1 12 6 9 1 1 EDIT: I made the init() work if you ever needed to reseed, or were testing values (this was necessary in my context as well)

Note: This code was originally included in the question above. In the interests of keeping the question short and focused, I've moved it to this Community Wiki answer. I found this code kicking around and it appears to work fine for getting a random number and then using the seed afterward but I'm not quite sure how the logic works (e.g. where the 2345678901, 48271 & 2147483647 numbers came from). 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. */

OK, here's the solution I settled on. First you create a seed value using the "newseed()" function. Then you pass the seed value to the "srandom()" function. Lastly, the "srandom()" function returns a pseudo random value between 0 and 1. The crucial bit is that the seed value is stored inside an array. If it were simply an integer or float, the value would get overwritten each time the function were called, since the values of integers, floats, strings and so forth are stored directly in the stack versus just the pointers as in the case of arrays and other objects. Thus, it's possible for the value of the seed to remain persistent. Finally, it is possible to define the "srandom()" function such that it is a method of the "Math" object, but I'll leave that up to you to figure out. ;) Good luck! 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 (my personal target environment): -- 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)