# Randomizing Program Execution with Random Number Generators

## Different ways to use Math.random() and its equivalents

Utilizing randomness in software isn’t something I’ve had to do for professional work, but it’s the basis of most of my creative software projects. Most notably, I make generative music hosted on Generative.fm. This involves a great deal of randomization, such as scheduling events at random times or making random selections of notes to play. Even my personal site has a background which slowly changes to a random color every few seconds.

When I first started creative coding projects, it wasn’t obvious to me how I could randomize my programs. I knew about `Math.random()`

, but I wasn’t sure how to apply it to all my use cases. Now these techniques are second nature, and I wanted to share some tips for anyone getting started with creative coding or generative art.

I’ll be using JavaScript throughout this post, but these techniques work with any programming language or library which has a random number generator like `Math.random()`

.

# Math.random()

In JavaScript, `Math.random()`

returns a pseudo-random number between 0 (inclusive, meaning it might return 0) and 1 (exclusive, meaning it can’t actually return 1). Run the embedded CodePen below to see numbers returned from `Math.random()`

:

This is nice if you need a number between 0 and 1, but what about other applications of randomness? What if you need a random number between 2 and 7? What if you want some part of your program to randomly execute about 25% of the time? You can do this and more with `Math.random()`

.

# Random Number Between 0 and <Max>

Getting a random number between 0 and some other number is simple. Just multiply the maximum desired number by `Math.random()`

, like so:

`function getRandomUpTo(max){`

return Math.random() * max;

}

Since `Math.random()`

returns a value between 0 (inclusive) and 1 (exclusive), this function will return a value between 0 (inclusive) and `max`

(exclusive).

# Random Number Between <Min> and <Max>

Now let’s write a function which returns a value within a range we specify.

Our function will take two parameters, `min`

and `max`

, and return a random number between those two values.

`function getRandomBetween(min, max) {`

// TODO: return a value between min and max

}

Since `min`

is the smallest number which should be returned by this function, let’s start by simply returning `min`

:

`function getRandomBetween(min, max) {`

return min; // TODO: make this value between min and max

}

This satisfies our condition that this function should return a value which is greater than or equal to `min`

. Now we can add a random, positive number to `min`

to get our desired output.

What numbers can we add to `min`

to finish our function? The smallest value we can add is 0, since adding a negative number would reduce the output below `min`

. The largest value we can add is the difference between `max`

and `min`

, or `max — min`

. For example, if we want a value between 2 and 7 and our function returns 2 + <some number>, the most we can add to keep the summation within our range is 5 (or 7 - 2). So we need a random number between 0 and `max — min`

. And hey, we just wrote a function to do that!

`function getRandomBetween(min, max) {`

return min + getRandomUpTo(max - min);

}

Or, in case you want to see the full arithmetic:

`function getRandomBetween(min, max) {`

return min + Math.random() * (max - min);

}

Remember, because `Math.random()`

will never return 1, this function will never return `max`

!

# Random Integer Between <Min> and <Max>

To get a random integer, we can use either `Math.ceil()`

or `Math.floor()`

to round our random numbers up or down to the nearest integer, respectively. Be careful to choose the correct method for your use case! For example, `Math.floor(Math.random())`

will always return 0, but `Math.ceil(Math.random())`

will almost always return 1. Likewise, let’s say you wrap a call to our previous function `getRandomBetween(min, max)`

with `Math.ceil`

, like this:

`Math.ceil(getRandomBetween(0, 5));`

This code snippet will return a value between 0 (**exclusive**) and 5 (**inclusive**); the inclusivity of the edges flipped! For this reason, I prefer to use `Math.floor()`

to get random integers, as the result will behave the same way as `Math.random()`

itself:

`function getRandomIntegerBetween(min, max) {`

return Math.floor(getRandomBetween(min, max));

}

This function returns an integer between `min`

(inclusive) and `max`

(exclusive), so the inclusivity of the edges matches the behavior of `Math.random()`

, which returns a value between 0 (inclusive) and 1 (exclusive).

# Random Element of Array

Now that we can get random integers, it’s easy to get a random element from an array. We just need a random integer between 0 and the array’s length (but not including its length!). I’ll use the first function we defined, `getRandomUpTo(max)`

:

`function getRandomFromArray(arr) {`

return arr[Math.floor(getRandomUpTo(arr.length)];

}

# Probabilities

Let’s say you have a branch of code which you only want to execute 25% of the time. Since the output of `Math.random()`

can be any number between 0 and 1, we know the value it returns will be less than 0.25 roughly 25% of the time. Just call `Math.random()`

and check that the output is less than the percentage you want, in this case 0.25:

`if (Math.random() < 0.25) {`

// do something

}

We could even write a function for this, which I’ll call `p`

:

function p(probability) {

return Math.random() < probability;

}if (p(0.25)){

// do something

}

To get pedantic for a moment, it’s most appropriate to use `<`

and not `≤`

since the return value of `Math.random()`

is inclusive of 0 and exclusive of 1. This means the expression `Math.random() ≤ 0`

could actually be `true`

, albeit *very* infrequently. Still, I’ll argue there should be exactly 0% chance our `p`

function returns `true`

when it’s called with `0`

. It doesn’t really matter in practice, but it’s worth mentioning anyway so I can feel smart.

In addition to control flow, I use this technique to grab a random sampling of elements from an array. For example, this snippet will return about half of the elements of an array, chosen at random:

`const elements = someArray.filter(() => p(0.5));`

Keep in mind this could return 0 elements or it could return all the elements, and everything in between. But if we run this code repeatedly, on average it will return about half the elements in the array.

These techniques provide everything I need to randomize my creative software projects. When I first started, I didn’t understand all the different ways `Math.random()`

could be used to do what I want, but I’ve since found it fulfills all my randomization needs. I’ll bet it covers yours too.

Thank you so much for reading.

You can follow me on Twitter or subscribe to my newsletter to receive paywall-free links to my Medium posts. If you’re not a paid Medium member, reading via these links won’t count against your monthly limit.

Check out

Generative.fmif you like ambient music or want to hear music which never ends nor repeats itself. Many users (myself included) find this type of music helps them concentrate while they work, study, or read, but also during activities like relaxing or meditating. The site is completely free and doesn’t feature advertising (unless you count my PayPal and Patreon links on the about page). And, it’s open source.