What's the easiest way to generate a random number in the range of 0-29?

use the Rand() command. At least I think it's Rand()

That gives flex numbers in between 0.000000 and 1.000000
What I need is integers. How do I convert those flexes to whole values?

Zeqmacaw supplied me with the answer:

dividend = rand() * 30 // 30 in my case
result = dividend - (dividend % 1)

Cog will truncate the float anyway. If this was for an array, you could do:

Cog will *not* truncate a float value in a symbol. I have tested this many times. If a symbol with a float value is used in a verb that expects an int, the verb will use the truncated value, but the symbol will still keep the float value.

Which is the purpose of:

result = dividend - (dividend % 1);

Oh, and although in theory that'll give 0 to 6, in practical applications, you will NEVER see 6.

rand() functions normally go from 0 inclusive to 1 non-inclusive. In other words, it NEVER returns 1. Whether cog follows these rules or not I have no idea.

The chance of getting 1 exactly (even if it doesn't follow that rule) is so small that you could simply put in a check to throw that value away if you get it and re-call the rand() function in a while() loop. The chance of having to call it more than once is either zero or infinitesimal. If it's infinitesimal, the chance of having to call it more than twice is even more (less? :p ) infinitesimal.

However, I would be VERY surprised if it did actually ever return 1. It was written by programmers after all, so they should know how rand() functions work.

source: Datamaster

But since I multiply the result of the rand with 30 before truncating any origional value below 0.03333... will result in 0. Thus it won't matter much, though statistically 0 will be called slightly less frequent.

1 (30) will only very rarely be called. But I only have 30 integers I'm using (0 through 29) so there is no 31st int. So in this special occasion I'll have to explicitly specify what to do.

The following code will generate a random number between 0 and 29, with 0 and 29 being as probably as any other:



The first line gets a random number between 0 and 29. Since rand() generates a number between 0 and 1, multiplying the product by any number will get you a range between 0 and that number. If you wanted a range between any two numbers X and Y, use this (just for future reference):


The second line will round to the nearest integer. X % 1 will return the decimal portion of X, so if X is 22.56, it will return 0.56. In our example, let's say randomNumber is 22.56. First we add 0.5, making it 23.06. Then we get the remainder of that by doing % 1, then subtracting it from 23.06. That leaves us with 23, which was rounded up from 22.56.

Now let's say the number was 22.12. When we add 0.5, it becomes 22.62, so when we subtract the remainder, it ends up being just 22.

Not sure if you wanted an explination or not but I figured I'd offer one anyway...If you still don't get it (or if I didn't explain it well) try it out in Windows Calculator and it should become clear.

I guess I'm missing the point. Why is it that we have to perform extra operations to remove the remainder?

This is apparently for an array, so my code with an extra symbol (for that one in a thousand chance) is all you need.

I don't know, mine rounds to the nearest integer, which is the more "proper" way to do it.

I can't remember how I did it, but if you look in my Rogue Squadron CTF mod for JK -- under CTF_main.cog, you'll see that you don't even need to truncate. Rand() DOES truncate (actually, it technically doesn't need to). I believe I used something similar to this:



anyways, if you look in that cog you should have no troubles.

Ok, so it was kinda superfluous.

Rand() just returns a random number between 0 and 1, it doesn't truncate and it doesn't not truncate. It just returns a number. It's truncated by COG when you use it as an array index.

Emon, truncation is better than rounding here, because your mthod makes the extremes less probable than the other values. Your second line of the algorithm makes sure that 0 only happens for values in the range of 0 to smaller than 0.5, whereas e.g. 2 can happen for values in the range of 1.5 to smaller than 2.5.
I'm with Giraffe here and would use a simple rand() * 30. If it's really possible to get 1 from rand() (which I think is not the case), it will only happen once in a millenium.

Yes, Rand() will return 1 eventually. If you don't believe me, try this out:

The value of i is random, but usually between 10,000 and 50,000. The lowest I got was 235, and the highest was 100,000. The practical side of this is you should check for i being 1.

Well, the reality is that it works. The rand () * 30 will work. No problems, at all.