World: r4wp

Here's a bug:

ran_arr_ptr/value: ran_arr_dummy   ;; the next random number, or 
-1

should be

ran_arr_ptr/value: :ran_arr_dummy

Yes, you were comparing

 - wrong - I was not comparing anything, nor complaining to anything 
 ;-) My question was more general, headed towards if in regards to 
 red/system architecture, the measure of being 8x slower than C (in 
 a concrete example guys were talking about), is good, or bad. I simply 
 don't remember outcome of prior discussions, that's all.

In limited tests so far, the indication was that Red/System was roughly 
as fast as unoptimised C, half as fast as optimised C compiled with 
GCC

This is a more elaborate test, though

Here's a real algorithmic bug:

if  (is_odd(ss) = 1) [

It's deceiving to write this in a form that looks like C. The Red 
evaluation rules compute this as

if is_odd (ss = 1) [

You would have to write

if 1 = is_odd ss [

But it's better to write

#define is_odd(x) [(x) and (1)] ; test on the unit bit of x

as

#define odd? (x) [(as-logic x and 1)]

if odd? ss [

Better keep the parentheses if you're going to use larger expressions 
as parameter:

#define odd? (x) [(as-logic (x) and 1)]

Arnold, if you clean up the code and make it look more like Red/System 
and less like C, we could add it to the library folder in the Red 
repo/

My plan for random number support was rather to implement the "Mersenne 
twister" algorithm than the Knuth's one. But in the meantime, Knuth's 
method would fine.

http://en.wikipedia.org/wiki/Mersenne_twister

Yes, we have the Twister in Syllable, too

You have

if  MM < ss [

but the C code has

if (ss>=MM)

so if you really want to reverse it, it has to be

if  MM <= ss [

However, it's more logical to put constants last, and it can also 
generate more optimal code in Red/System

There are more off-by-one errors in there, so the algorithm is not 
the same

The pointer initialisation earlier needs to be

ran_arr_ptr: :ran_arr_dummy

It should actually crash on what you have now, but if it doesn't, 
it pokes a value over an unitialised pointer, so any value in your 
program could be corrupted

Thanks for the compliment Doc, not really sure what you mean exactly 
by making it more like Red/System and less C: use more descriptive 
names? I will take a closer look at some ed/System examples out there.

Thanks Kaj for finding those and for the tips, the size of MM makes 
it the same in effect in this case, but it has to be <= then. Program 
not crashing, I was lucky then! off-by-one errors? My index goes 
from 1 up, where in C it is from 0 up, I had to debug this to make 
sure elements were swapped in the same way as in the original program. 
That is also why I declare KKP and LLP to as to save from adding 
1 to KK and LL over and over again. 


Knuth's algorythm was the first one I found, and I knew already of 
its existence, so it made sense to use what you have. Sure my Red/System 
code is not optimised.


Going to work on it now and tomorrow, and later I take on the Twister. 
It is a good exercise!

Actually, your work on porting that algorithm has many values, like 
showing us the trade-offs of 1-base vs 0-base indexing at Red/System 
level.

About "making it more like Red/System" means applying Red/System 
coding style, which is not formaly defined, but it is very close 
to the official Rebol one. For example, the naming rules for variable 
and function names are the same as in Rebol.

About odd, this solution managed to get all odd number from the even 
ones. Your solution is way more elegant, better fitting the language.

Base-1 Base-0, my personal view on this, it is the programmers choice 
on the level of the source code. What happens beneath the surface 
is compiler/linker sh*t. As a programmer and a human being I start 
to count at 1. 0 is not the new number 1 nor is 1 the new number 
2 etc. It is only an addressing issue, compare to the post. Houses 
in the street are numbered from 1 up to N. The first address a computer 
has in an array is the all 0 address, which is the first "pidgeon-hole" 
to be used. The computer doesn't know 0 as we understand it. Well 
you know all about it.

And the computer must adapt to the human, or the human pulls the 
plug! ;)

CPU are optimized for 0-based accesses. Using 1-base indexing will 
make Red/System a bit slower than it needs to be.

OTOH, you can always use pointer arithmetics to get a 0-base indexing 
model.

Arnold: does the C code use register variables?

Yes it does

I was going to aslk whether register varaibles still improve performance 
with modern CPUs with on-chip caches?

The source (with some displays to help compare both versions) is 
in the Red Randompublic folder

If register variables do improve performance I was going to add register 
variables to the Red/System V2 wish list.

I would certainly expect that to be the case. My code is just Red/System 
compilable and executable.

Funny

: #define odd? (x) etc as Kaj suggested gives a compile error on 
line where it is used: 
*** Compilation Error: undefined symbol: odd? 

*** in file: %/Users/Arnold/data/develop/red/testscripts/random.reds 
*** in function: ran_start
*** at line: 117 
*** near: [odd? ss [

Shouldn't  it be odd?(ss) ?

macros require the (), unlike function calls.