World: r4wp

To get zeroed memory, you can use MAKE in my C library binding

Is the second time for 1000 x C? Then Red/System comes out almost 
8 times as slow as C. I wouldn't expect that, either

(I am trying to avoid as much C as possible) I am happy with the 
result being the same now, could not judge where the memory was allocated 
but it was consistent during all my testruns, as was the C array 
with it's unexplainable filled fields.

Yes that is a lot, completely agreed. I'll have a third look. Seems 
the same stuff in the loops.

I usually get zero-filled memory in Red/System, too, but it's not 
guaranteed

C is supposed to work like that, for performance

Good to know it is not guaranteed. Trouble uploading .reds file stays 
Empty.

8 times slower - do you consider it bad, or good? I mean - in regards 
to how is Red/System designed ...

If it's correct, it's bad. So I think it's not correct :-)

Still prompt to jump to conclusions without even looking at what 
the code does? :-)

I'm torn between defending Red/System and defending my fellow countryman

My comment was directed to Pekr. ;-)

No need to defend me now. I hope I am wrong, it happens ;) Should 
have made the folder public do that anyway.

randompublic folder added.

Still prompt to jump to conclusions without even looking at what 
the code does
 - can you really read my message as jumping to any conclusion?

Yes, you were comparing the speed of two programs without being sure 
they were implementing exactly the same algorithm.

Knuth's code could compete at C obfuscated contests. Arnold seems 
to have done a literal translation to Red/System but keeping the 
same obfuscated symbols, so not easy to read. However, it seems at 
first look that the algorithm has been well preserved.

Congrats to Arnold for doing this conversion and getting the right 
results! :)

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