Javascript function to generate random integers with nonuniform probabilities

Question

In javascript (or jquery) is there a simple function to have four integers with their probability values: 1|0.41, 2|0.29, 3|0.25, 4|0.05

how can I generate these four numbers taking into account their probabilities ?

This question is very similar to the one posted here: generate random integers with probabilities

HOWEVER the solution posted there:

function randomWithProbability() {
  var notRandomNumbers = [1, 1, 1, 1, 2, 2, 2, 3, 3, 4];
  var idx = Math.floor(Math.random() * notRandomNumbers.length);
  return notRandomNumbers[idx];
}

states in the comment "create notRandomNumbers dynamically (given the numbers and their weight/probability)"

This is insufficient for my needs. That works well when the probabilities are say 10%,20%, 60%,10%.

In that case constructing notRandomNumbers with the required distribution is easy and the array size is small. But in the general case where probabilities can be something like 20.354%,30.254% etc , the array size would be huge to correctly model the situation.

Is there a clean solution to this more general problem?

EDIT: Thanks Georg, solution accepted, here is my final version, which may be useful for others. I have split the calculation of the cumulative into a separate function in order to avoid extra additions at each call to get a new random number.

function getRandomBinFromCumulative(cumulative) {
    var r = Math.random();
    for (var i = 0; i < cumulative.length; i++) {
        if (r <= cumulative[i])
            return i;
    }
}
    function getCummulativeDistribution(probs) {
    var cumulative = [];
    var sum = probs[0];
    probs.forEach(function (p) {
        cumulative.push(sum);
        sum += p;
    });
    // the next 2 lines are optional
    cumulative[cumulative.length - 1] = 1; //force to 1 (if input total was <>1)
    cumulative.shift();  //remove the first 0
    return cumulative;
}
function testRand() {
    var probs = [0.1, 0.3, 0.3, 0.3];
    var c = getCummulativeDistribution(probs);
    console.log(c);
    for (var i = 0; i < 100; i++) {
        console.log(getRandomBinFromCumulative(c));
    }
}

Answer 1

Just accumulate the probabilities and return an item for which current_sum >= random_number:

probs = [0.41, 0.29, 0.25, 0.05];

function item() {
    var r = Math.random(), s = 0;
    for(var i = 0; i < probs.length; i++) {
        s += probs[i];
        if(r <= s)
            return i;
    }
}

// generate 100000 randoms

a = [];
c = 0;
while(c++ < 100000) {
    a.push(item());
}

// test actual distibution

c = {}
a.forEach(function(x) {
    c[x] = (c[x] || 0) + 1;
});

probs.forEach(function(_, x) {
    document.write(x + "=" +  c[x] / a.length + "<br>")
});

Answer 2

Create a second parallel array with corresponding weights and use a "wheel" algorithm to get an index.

function randomWithProbability()
{
    var notRandomNumbers = [1,2,3,4];

    var w = [0.41, 0.29, 0.25, 0.05];
    var placehldr = 0;
    var maxProb = 0.41;
    var index = Math.floor(Math.random() * w.length);
    var i = 0;

     placehldr = Math.random() * (maxProb * 2);
    while(placehldr > index )
    {
        placehldr -= w[index];
        index = (index + 1) % w.length
    }

    return (notRandomNumbers[index]);

}

This video has a good explanation as to why it works, it's easier to understand with the visual representation. https://www.youtube.com/watch?v=wNQVo6uOgYA

Answer 3

There is an elegant solution only requiring a single comparison due to A. J. Walker (Electronics Letters 10, 8 (1974), 127-128; ACM Trans. Math Software 3 (1977), 253-256) and described in Knuth, TAOCP Vol. 2, 120-121. You can also find a description here, generate random numbers within a range with different probabilities.