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:
 It returns a value computed from the parameters
 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?
8 answers

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.

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.
https://github.com/MostlyAdequate/mostlyadequateguide/blob/master/ch3.md

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
And in your "production" code:
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 nonpure 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 whyMath.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 lowlevel bit manipulations or other operations that result in an unpredictable (but not really random) output.In JavaScript, the process involved is implementationdependent, 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 ofseedable_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 nonpure, 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 nondeterministic, it also has a sideeffect: it will cause future calls to
math.random()
to return a different answer. And a randomnumber 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 ofMath.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 forMath
). 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 objectoriented 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.