In an XNA book I read that this code does an action with a 0.2% of probability but I don't' understand why:
float chance = 0.2f;
if((float)rand.Next(0,1000) / 10 <= chance)
{
...
}
I understand the statement, but not the reasoning for that equation. Can anyone explain me, please?
(float)rand.Next(0,1000) / 10
Picks a random number between 0 and 1000, the divides by 10. This gives you a random number between 0 and 100. If that random number is less than or equal to your chance (<= .2), then the statement is true and whatever is inside the if statement is executed.
If you want to get a .2% chance, that means that for every .2% of the times you run this code it will be true. So how do we do that? Pick a random number between 0 and 100, if it's less than .2 it's true.
Throw a random dart at this image:
If the dart were truly random, you'd expect it to hit blue 50% of the time and red 50% of the time. So we want something to happen 50% of the time, this is what we would use. So what if we wanted it to happen .2% of the time? I means our image needs to look at bit less equal.
Throw that random dart at this image and you'll hit blue .2% of the time.
EDIT to address your comment
The thing about random numbers is that they don't care about the number that was chosen before them. If you were to flip a fair coin, you have a 50% chance of it landing on heads and a 50% chance of it landing on tails. So should would you be surprised if you flipped it twice in a row and it came up heads both times? No, I don't think you would. How about if you flipped it 6 times, would you be surprised if if came out 4 tails and 2 heads? No that is totally possible. How about 6 heads in a row? Well that is certainly less expected, but it's not impossible. What about 100 flips and they're all heads? Now that seems totally impossible. But it's not, it's just very, very unlikely. Here's the thing though. If you're on flip 99 and they've all been heads up until that point, there's still only a 50% chance that the next flip will be heads too. The next flip has nothing to do with any of the previous flips or any of the flips to come after. Just because you've had 99 heads in a row doesn't make it any more likely that the next flip will be tails (see Gambler's fallacy). However as the sample size grows the number of heads and number of tails will start to equalize. See this simulated coin toss distribition:
As you can see, there are times where if you stopped right then, things would look very unbalanced. But as the sample size continues to grow, it does start to equalize towards 50/50. You can also see that I got lucky and this animated gif matches the color scheme I picked :).
Probability belongs to statistics. Statistics is one thing that people are typically not good at (if you need proof of that, just look at all the lottery players). It is however very beneficial to study statistics. It'll help you in programming and life in general.
Basically what you should take away from this is:
There is no reason. It's just a stupid thing which works but is completely unnecessary. The author probably just wanted to write down the chance as percent and not as permille .
Better is:
// In Permille: 2‰ == 0.2% == 0.002
int chance=2;
if(rand.Next(0, 1000) <= chance)
{
[...]
}
It will give you the same result but without those divisions and conversions to float.
Or if you prefer floating points over fixed numbers:
double chance=0.002;
if(rand.NextDouble() <= chance)
{
[...]
}
The part (float)rand.Next(0, 1000) generates a number between 0.0f and 999.0f inclusively.
Then, you divide it by 10 to get a number from 0.0f to 99.9f.
Checking if the number is below or equal to 0.2f checks if we hit the desired percentage, hence giving it a 0.2% chance of entering that if block.
Why the equation (float)rand.Next(0, 1000) / 10? Because you want to at least have a chance of getting into that if block.
If it had been simply rand.Next(0, 100), it would have entered the loop 1% of the time (when it would have given 0).
If my maths are not actually failing me this morning, by using the (float)rand.Next(0, 1000) / 10, you get the range from 0 to 2 (3 numbers) that give you a chance of entering that loop (since they are the only that x < 10 >= 0.2). 3/1000 gives your 0.003, or 0.3% chance (you'd have to remove that = from <= to get that actual 0.2%).
Instead, I recommend you to use rand.NextDouble() in your code. It is less obscure for other programmers (or yourself after a few months not looking at the piece of code) and more flexible.
Example of use in your context:
const float Chance = 0.2f; // I gave them programmers consts, programmers loooove const variables.
const float Percent = Chance / 100.0f; // divide by 100 to actually get the 0.2%
if (rand.NextDouble() < Percent)
{
...
}
Sorry I misinterpreted your question, here is the actually working code simplified as much as possible so that it's easier to see what's going on.
double chance = 0.2; //we use real percentages now
//We choose a random number in [0...999] because we want enough precision for 1000
//different chances (100% to 0.1% or even 0%), we multiply our chance by 10 to
//move it from the 0.0~100 range into the 0~1000 range
if(Random.Next(0,1000) < chance * 10)
{
...
}
This is the old, wrong answer, here for reference only, I missed that it was .2% and not the 2% I assumed
I don't get the equation either its convoluted, we could do without the weird division by and 10 and it's not clear why a random number in [0...999] is chosen instead of a random number in [0..99], maybe that's why you're having trouble with it. Let's get rid of the unnecessary cast and the division and clean it up as much as we can. The equivalent and, in my opinion, much more readable version would be:
double chance = 2; //we use real percentages now
if(Random.Next(0, 100) < chance)
{
...
}
ints.
\$\endgroup\$
.2f.
\$\endgroup\$