I was looking again at the simple random number generator shown in 'Thinking Forth' and find myself wondering how the 'choose' word works. The code is below with my comments. The following line is what confuses me:



You pass the range of random number on the stack, it calls the random function so you have ( range random -- ). They are multiplied and pushed to stack as a double. The swap puts the low word/cell on top of the stack and then it is dropped. How does this make the number returned within range specified? It might be simple and I am overlooking it but it has me stumped at this point.

This... is actually kindof neat. And it's simple fixed-point math.

The word RANDOM returns a "random" cell-sized value (it's not particularly random, and the seed is atrocious). Think of this as being a value between 0 and just below 1. UM* multiplies that value by an exclusive upper bound, returning a 2-cell fixed-point result, the integer part being the high bits of the result and the fractional part being the low bits. It then discards the fractional part.

Thanks! I also asked on the Forth Facebook group and it sort of dovetailed with a discussion a few days ago about the use of um* vs. mod. It turns out to be better to use um*.

The seed might not be excellent but it works on every system, which is why I'm guessing why it was used. It is not the most random of random generators but it is short, simple and fairly good.

I'm still at the point of 'translating' Forth to a more familiar language in my head, sort of like you would do when learning a new spoken language. I think this hinders understanding how tings work at times.

Yeah, I tried to mentally convert Forth to Python at the beginning, and mostly I got a headache. It's just too different. Now I have the reverse problem: I expect computer programs to start at the beginning, go to end, and then stop, and not to have some definition of some function stored in whatever other file somewhere. Also, I tend to want to use DEFER constructs for everything. Given this is basically a way of using first-order functions, I may have to seriously look at Haskell now .