Random number in a range, biased toward the low end of the range [duplicate]

Question

I have an input of two values, let's say 1 and 10. Lesser numbers should overall occur more often in the output than higher numbers, while there is a peak in the probability at #2:

1: very common
2: extremely common       
3: very common     
4: common              
5: somewhat common  
...                  
10: extremely rare   

How do I achieve this? My code until now looks like this:

function getValue($min, $max) {
    return random($min, $max);
}

Answer 1

Assuming you have a random() function that returns a uniformly-distributed numeric value in the interval [0, 1)...

(I see the edit attempt to "fix" the mismatched bracket above, but this is deliberate and carries specific meaning)

random() - random()

Gives a distribution that peaks at 0 and falls off toward -1 and 1.

abs(random() - random())

Peaks around 0 and falls off toward 1

 floor(abs(random() - random()) * (1 + max - min) + min)

Gives you a random number between min and max, with outputs closer to min being more common, falling off linearly toward the max.

---

Note as pointed out by Logan Pickup in the comments below, there's a slight mathematical artifact here if you're using this to generate continuous random numbers (ie. without the floor): the only way to get zero out of abs is to start with zero, but you can get a value of epsilon if the input is either positive or negative epsilon. So you have about half the chance of getting exactly zero as you have of getting the next larger representable number. If you're using this with floor after the abs to generate random integers, then this little quirk will be swamped and not noticeably affect the result.

---

Using inverse transform sampling you can get this same linear distribution (without the 0 artifact) with one random sample via the formula:

1 - sqrt(1 - random())

(and we can apply the same scale/offset/floor approach to get a corresponding discrete distribution)

You can find methods to get custom-shaped probability distributions in this answer or the links suggested in comments above.

Answer 2

Let's say "rand()" gives you a random number between 0 and 1 (inclusive).

pow(rand(), 2)

will give you an answer between 0 and 1 (inclusive), but the result is more likely to be close to zero, following a quadratic curve.

pow(rand(), 0.5)

will give you an answer between 0 and 1 (inclusive), but the result is more likely to be close to one, following a square root curve.

And since the min and max of the output are still 0 and 1, this distribution can be mapped to any range (given min, max, and the exponent p) like so:

result = min + (max - min) * pow(rand(), p)

Using different values of p can bias you towards the minimum or maximum value depending on your needs: (example of mapping a 0-1 range by raising x to different powers. From top to bottom: 1/4, 1/2, 2, 4)

Experiment with different powers to find what works for you. Just remember that bigger powers greater than one will bias you towards the minimum value, and smaller powers less than one but greater than zero will bias you towards the maximum value.

You can also swap max and min to flip the distribution of results, and if you want integer results, I'd use floor(x), increase max by one, and either use a rand() function that is exclusive at the top end (won't return 1.0) or clamp the final output to the range to filter out that rare case.

Answer 3

Why not use a system similar to advantage/disadvantage as used in DnD 5e?

It boils down to: disadvantage: roll 2 (or any number of) dice and keep the lowest. advantage: roll 2 (or any number of) dice and keep the highest.

for 1 out of 2 dice this gives a linear chance decreasing as you get higher:

example: http://anydice.com/program/1227

for one out of more dice this gives a curve:

example: http://anydice.com/program/585d

And picking more dice out of the set favors numbers in the lower-middle of your range.

I hope this helps

Answer 4

You can use a local variable to save a random call:

function F(min, max) {
  var t = random(); //Assuming this returns a value between 0 and 1
  return min + (max - min) * t * t;
}

This makes a non linear distribution where values close to min are more frequent. You can force even more extremal distribution by inserting t = t*t or user a pow with other values.

Answer 5

A naive and not efficient algorithm that would give you a linear distribution:

vector values;
int iterations = 1;
for ( val = max; val >= min; --val ) {
  for ( i = 1; i <= iterations ; ++i )
    values.push_back( val );

  ++iterations;
}

// The goal is to have in your values vector something like this for min = 1 and max = 4:
// [1, 1, 1, 1, 2, 2, 2, 3, 3, 4]

return values[random(0, values.size() - 1)];

This will give you what you need.

Answer 6

If this is for a game, often you want to tweak values intuitively rather than rely on some existing distribution.

A good way to do this is to pick numbers from an array, and duplicate the values you want more than one. For example, here's some python code that does that. The nice thing about it is that you can see pretty easily the probability of the different options.

import random
values = [
1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3,
4, 4, 4, 4,
5, 5, 5, 5,
6, 6, 6,
7, 7,
8,
9,
10
]
random.choice(values)

Obviously this only makes sense with a small number of values.

Alternatively, if you have a probability distribution in mind you can use Inverse Transform Sampling. It can take the uniform random number from 0 to 1 and map it so that it matches any probability distribution. It's requires some maths, but if you have some good libraries they should be able to help you out.

Answer 7

If you have uniformly distributed random numbers, you can use those as the parameter to a mathematical function that has a exponential-like shape, so that most numbers in the random range yield a low value. The initial random input can be normalized, then scaled to your range, so the function is well-behaved.

For example, the following function, if given normalized values from 0 to 1 as input:

You can tweak the parameters to make this cover the whole output range from 0 to 1. And if you need higher numbers, just multiply or offset the result.

I didn't check this mathematically, but it seems good enough experimentally.

Answer 8

I recommend using the function:

where s and g represent your minimum and maximum values, respectively, R is a random number between 0 and 1 (inclusive) and n is a pre-determined constant. The notation ||x|| represents the nearest integer to x.

An example in PHP 5:

function biasedRandom($min, $max) {
  $power = 2;
  # lcg_value() returns a random number between 0 and 1
  $bias  = pow(lcg_value(), $power);
  return round($min + ($max-$min) * $bias);
}

---

In an IPython notebook I ran my function 1000 times each for different powers. It generated this graph, where each value (x-axis) is plotted against the probability of it occurring (y-axis):

The graph shows that as p, the power which we raise the random number to, increases, the 'steepness' of the graph also increases.

That is to say, a higher value of p will make the smallest value, in this case 1, to have a much higher probability of occurring than the highest value, 10. See the green line, where p equals 8.

In the case of the blue line, where p is only equal to 2, the bias is far less extreme, and all numbers are closer in probability.

This animation demonstrates how the probabilities of each value change with different values of p:

I used this python function to generate each of the biased random numbers used as data in all of the following graphs.

These box-plots each show the distribution of 500 values generated by my function, with powers of (from top to bottom) 2, then 2.5 then 4.

The box-plots clearly show that smaller numbers are more common than larger numbers (the medians are all less than 5.5), and that there is a higher density of values towards the lower end of the spectrum. However, one can also see how high values (all the way up to ten) still emerge sometimes.

If we compare the box-plots we can again see that a lower power (the top-most box-plot has the lowest power, in this case 2) leads to a more even spread of values, with high values appearing more frequently and low values appearing less frequently than when using higher powers.

Without rounding the function's final result, we can obtain the following visualisation, which shows clearly the higher density of smaller numbers. Values are plotted as they are obtained by the function.

The above image shows the distribution of results for powers 8, 16 and 32. The layout is intended to represent a number line, with 1 on the far left and 10 on the right.

Answer 9

Couple other ideas:

Folded Normal Distribution.

This is achieved by generating a standard Gaussian random, then running it through abs(). Values greater than 1 are possible, feel free to deal with it however you choose; clamp it, re-randomize, ignore.

Wald Distribution.

Also known as the Inverse Gaussian.

0 as a result has a very low probability, while values near 0 have a very high probability, trailing off towards infinity (see above about clamping).

Answer 10

The important thing is to re-map the function from 0-1 to what you desire. A big part of this depends on just what distribution you want from it. I suspect you want something that has an exponential decaying type curve in it, although you have to really ask yourself what you want the distribution to look like. A couple of possibilities are an exponential decay function, and a inverse function, although in both cases the edge cases need to be well studied. I'm not going to give you the code, but rather the formulas. Assume R is a random number between 0-1.

Inverse Linear:

while (R<.1) {
    R*=10;
}
return ceil(10-(1/(R))

Exponential Decay:

// Will likely need to work on some edge cases
return 10-10*(e-e^R)

To test it, I suggest that instead of using real random numbers, iterate through, say, every 0.01 value of R, and see if the distribution is correct. If there are points that lie outside your range, find a way to remove them. Good luck!

Answer 11

One can use a simple formula like so:

function getValue(min,max) {
    return min-1+Math.pow((max-min+1),Math.random());
}

When given min as 1 and max as 10 this generates a number from 1.0 to 10.0 where 10.0 is rare. Remember Math.random() generates a uniform random number from 0.0 to 1.0

Here is some R code to show you the results:

(function(min,max){ 
    x=min-1+(max-min+1)^runif(10000); 
    print(summary(x)); 
    hist(x)
 })(4,28)

Answer 12

You could call the random function twice:

 function getValue($min, $max) {
     return random($min,random($min, $max));
 }

For numbers 1 - 5, the probabilities for getValue(1,5) are
1 = 137 out of 300
2 = 72 out of 300
3 = 47 out of 300
4 = 27 out of 300
5 = 12 out of 300