# Is a function that calls Math.random() pure?

Is the following a pure function?

``````function test(min,max) {
return  Math.random() * (max - min) + min;
}
``````

My understanding is that a pure function follows these conditions:

1. It returns a value computed from the parameters
2. It doesn't do any work other than calculating the return value

If this definition is correct, is my function a pure function? Or is my understanding of what defines a pure function incorrect?

No, it's not. Given the same input, this function will return different values. And then you can't build a 'table' that maps the input and the outputs.

From the Wikipedia article for Pure function:

The function always evaluates the same result value given the same argument value(s). The function result value cannot depend on any hidden information or state that may change while program execution proceeds or between different executions of the program, nor can it depend on any external input from I/O devices

Also, another thing is that a pure function can be replaced with a table which represents the mapping from the input and output, as explained in this thread.

If you want to rewrite this function and change it to a pure function, you should pass the random value as an argument too

``````function test(random, min, max) {
return random * (max - min) + min;
}
``````

and then call it this way (example, with 2 and 5 as min and max):

``````test( Math.random(), 2, 5)
``````

A pure function is a function where the return value is only determined by its input values, without observable side effects

By using Math.random, you are determining its value by something other than input values. It's not a pure function.

source

Pure functions always return the same value for same input. Pure function are predictable and are referential transparent which means that we can replace function call with the output returned and it will not change the working of program.

No, it isn't. You can't figure out the result at all, so this piece of code can't be tested. To make that code testable, you need to extract the component that generates the random number:

``````function test(min, max, generator) {
return  generator() * (max - min) + min;
}
``````

Now, you can mock the generator and test your code properly:

``````const result = test(1, 2, () => 3);
result == 4 //always true
``````

``````const result = test(1, 2, Math.random);
``````

No, it isn't a pure function because its output doesn't depends on the input provided (Math.random() can output any value), while pure functions should always output the same value for same inputs.

P.S for me at least and for many others, redux made the term pure function popular. Straight from the redux docs:

Things you should never do inside a reducer:

• Mutate its arguments;

• Perform side effects like API calls and routing transitions;

• Call non-pure functions, e.g. Date.now() or Math.random().

The simple answer to your question is that `Math.random()` violates rule #2.

Many other answers here have pointed out that the presence of `Math.random()` means that this function is not pure. But I think it's worth saying why `Math.random()` taints functions that use it.

Like all pseudorandom number generators, `Math.random()` starts with a "seed" value. It then uses that value as the starting point for a chain of low-level bit manipulations or other operations that result in an unpredictable (but not really random) output.

In JavaScript, the process involved is implementation-dependent, and unlike many other languages, JavaScript provides no way to select the seed:

The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user.

That's why this function isn't pure: JavaScript is essentially using an implicit function parameter that you have no control over. It's reading that parameter from data calculated and stored elsewhere, and therefore violates rule #2 in your definition.

If you wanted to make this a pure function, you could use one of the alternative random number generators described here. Call that generator `seedable_random`. It takes one parameter (the seed) and returns a "random" number. Of course, this number isn't really random at all; it is uniquely determined by the seed. That's why this is a pure function. The output of `seedable_random` is only "random" in the sense that predicting the output based on the input is difficult.

The pure version of this function would need to take three parameters:

``````function test(min, max, seed) {
return  seedable_random(seed) * (max - min) + min;
}
``````

For any given triple of `(min, max, seed)` parameters, this will always return the same result.

Note that if you wanted the output of `seedable_random` to be truly random, you'd need to find a way to randomize the seed! And whatever strategy you used would inevitably be non-pure, because it would require you to gather information from a source outside your function.

In addition to the other answers that correctly point out how this function is non-deterministic, it also has a side-effect: it will cause future calls to `math.random()` to return a different answer. And a random-number generator that doesn’t have that property will generally perform some kind of I/O, such as to read from a random device provided by the OS. Either is verboten for a pure function.

From mathematical point of view, your signature is not

``````test: <number, number> -> <number>
``````

but

``````test: <environment, number, number> -> <environment, number>
``````

where the `environment` is capable of providing results of `Math.random()`. And actually generating the random value mutates the environment as a side effect, so you also return a new environment, which is not equal to the first one!

In other words, if you need any kind of input that does not come from initial arguments (the `<number, number>` part), then you need to be provided with execution environment (that in this example provides state for `Math`). The same applies to other things mentioned by other answers, like I/O or such.

As further example, you can also notice this is how object-oriented programming can be represented - if we say, e.g.

``````SomeClass something
T result = something.foo(x, y)
``````

then actually we are using

``````foo: <something: SomeClass, x: Object, y: Object> -> T
``````

with the object that has its method invoked being part of the environment.