Random Float between 0 and 1 in PHP

Question

How does one generate a random float between 0 and 1 in PHP?

I\'m looking for the PHP\'s equivalent to Java\'s Math.random().

Answer 1

function mt_rand_float($min, $max, $countZero = '0') {
    $countZero = +('1'.$countZero);
    $min = floor($min*$countZero);
    $max = floor($max*$countZero);
    $rand = mt_rand($min, $max) / $countZero;
    return $rand;
}

example:

echo mt_rand_float(0, 1);

result: 0.2

echo mt_rand_float(3.2, 3.23, '000');

result: 3.219

echo mt_rand_float(1, 5, '00');

result: 4.52

echo mt_rand_float(0.56789, 1, '00');

result: 0.69

Answer 2

You may use the standard function: lcg_value().

Here's another function given on the rand() docs:

// auxiliary function
// returns random number with flat distribution from 0 to 1
function random_0_1() 
{
    return (float)rand() / (float)getrandmax();
}

Answer 3

what about:

echo (float)('0.' . rand(0,99999));

would probably work fine... hope it helps you.

Answer 4

This question asks for a value from 0 to 1. For most mathematical purposes this is usually invalid albeit to the smallest possible degree. The standard distribution by convention is 0 >= N < 1. You should consider if you really want something inclusive of 1.

Many things that do this absent minded have a one in a couple billion result of an anomalous result. This becomes obvious if you think about performing the operation backwards.

(int)(random_float() * 10) would return a value from 0 to 9 with an equal chance of each value. If in one in a billion times it can return 1 then very rarely it will return 10 instead.

Some people would fix this after the fact (to decide that 10 should be 9). Multiplying it by 2 should give around a ~50% chance of 0 or 1 but will also have a ~0.000000000465% chance of returning a 2 like in Bender's dream.

Saying 0 to 1 as a float might be a bit like mistakenly saying 0 to 10 instead of 0 to 9 as ints when you want ten values starting at zero. In this case because of the broad range of possible float values then it's more like accidentally saying 0 to 1000000000 instead of 0 to 999999999.

With 64bit it's exceedingly rare to overflow but in this case some random functions are 32bit internally so it's not no implausible for that one in two and a half billion chance to occur.

The standard solutions would instead want to be like this:

mt_rand() / (getrandmax() + 1)

There can also be small usually insignificant differences in distribution, for example between 0 to 9 then you might find 0 is slightly more likely than 9 due to precision but this will typically be in the billionth or so and is not as severe as the above issue because the above issue can produce an invalid unexpected out of bounds figure for a calculation that would otherwise be flawless.

Java's Math.random will also never produce a value of 1. Some of this comes from that it is a mouthful to explain specifically what it does. It returns a value from 0 to less than one. It's Zeno's arrow, it never reaches 1. This isn't something someone would conventionally say. Instead people tend to say between 0 and 1 or from 0 to 1 but those are false.

This is somewhat a source of amusement in bug reports. For example, any PHP code using lcg_value without consideration for this may glitch approximately one in a couple billion times if it holds true to its documentation but that makes it painfully difficult to faithfully reproduce.

This kind of off by one error is one of the common sources of "Just turn it off and on again." issues typically encountered in embedded devices.

Answer 5

update: forget this answer it doesnt work wit php -v > 5.3

What about

floatVal('0.'.rand(1, 9)); 

?

this works perfect for me, and it´s not only for 0 - 1 for example between 1.0 - 15.0

 floatVal(rand(1, 15).'.'.rand(1, 9)); 

Answer 6

class SomeHelper
{
     /**
     * Generate random float number.
     *
     * @param float|int $min
     * @param float|int $max
     * @return float
     */
    public static function rand($min = 0, $max = 1)
    {
        return ($min + ($max - $min) * (mt_rand() / mt_getrandmax()));
    }
}