World: r3wp

even when the customers are pounding you for fixes... :-)

Kib2, try this:
>> head insert/dup copy "" "abc" 5
== "abcabcabcabcabc"

And then just wrap it up:

    string-of: func [
        "Returns a string of <value> repeated <count> times."
        count [integer!]
        value [word! char! any-string!]
    ][
        head insert/dup copy "" value count
    ]

BrianH and Gregg : thanks, I need to write all these tips on a page 
now.

as I've just finished implementing nested list in my markup engine.

Still having fun with REBOL, kib? Watch it! You're caught in the 
web now. ;-)

Geomol: more than ever. But I'm rather fed up now working on this 
markup engine. I need fresh air.

I was thinking of a game, and in fact I've found one, but I think 
I need your help. Beware : that's not easy !

See http://www.indigopuzzles.com/ipuz/help.action?helpId=hashi/index

:-) We have a game group. You could start posting there and see, 
what will happen.

games

Thanks Geomol. I think I have to study game programming before!

How could I generate a random number (a real number) between 2 given 
values, ie between -pi and pi ?

random pi gives me an integer

interesting

I can think of a way to do it, but it isn't easy. I have a feeling, 
REBOL has a problem with random decimals.

I've posted this issue on rebdev. R3 rounds decimals as well.

You can build a hex value from an integer with TO-HEX.
And you can put that hex value into a decimal using struct!

So something like:

>> d: make struct! [v [float]] none
>> i: to integer! (random 2 ** 32) - (2 ** 31) - 1
== -198913422
>> h: to-hex i
== #F424D272
>> change third d h
>> d/v
== 11532.55078125

To get the result between some values, you have to use a factor somewhere.

hm, I'm not sure, this is right. The length of third d is 8. It should 
be 4, I guess.

Yeah, the change line should read:

change third d debase/base h 16

I said, it wasn't easy. ;-P

I'm wondering, if this has come up before? I didn't find a random 
decimal function in the library (rebol.org). Some of the math guys 
here may have a better way?

how about randoming a big integer and divide by that integer and 
multiply with your desired max-value?

Yes, that's an easy way, but I'm afraid rounding will lead to the 
result not being very random (or a limit in possible outcome). It 
has to be checked at least.

Rebol decimal! is 8 bytes and integer! is only 4 bytes. So you would 
need to make a struct of 2 integer!, then swap its contents with 
a struct of 1 decimal!

I used float up there, which is 32 bit afaik. What do I write to 
make a 64 bit decimal struct?

You wrote float, but you didn't get one :)

You can write make struct! [v [decimal!]] none

ah :D

Sorry guys, I was away for an hour. Henrik : that's the way I was 
thinking of it, but it seems weird.

I'm wondering, why I got that float into my head.

Anton, are you sure, I don't get a 4 byte float?

>> d: make struct! [v [float]] none
>> d/v
>> type? d/v
== decimal!
>> length? third d
== 4

The length of a decimal is 8.

missed a line:

>> d/v
== 0.0

... no longer sure ...! :-)

My error, sorry.

http://www.rebol.com/docs/library.html#section-4.2

d: make struct! [v [decimal!]] none
i: make struct! [v1 [integer!] v2 [integer!]] none

i/v1: to integer! (random 2 ** 32) - (2 ** 31) - 1
i/v2: to integer! (random 2 ** 32) - (2 ** 31) - 1

change third d third i

The random decimal is d/v

Now divide by max-decimal (whatever that is) and multiply by desired 
range (eg. pi).

:-) I follow you, when you say, you're no longer sure. This is a 
little used corner of REBOL (for me at least).


I think, we have a problem still. random 2 ** 32 seem to never give 
results above 2 ** 31.

Never returns:

>> until [a: random 2 ** 32 a > (2 ** 31)]

That would be a problem, yes.

And since we don't have a 16 bit datatype (or maybe we do with a 
string or other series somehow!?), we have to make 8 times random 
256 (and subtract 1).

We can substitute the struct of 2 integer!s with a struct of 8 char.
Maybe this is useful:
>> random 255.255.255.255.255.255.255.255
== 168.97.60.251.15.20.205.31

Kib asked a simple question about random and decimals. It seems to 
be a bit of a hazzle to get what we want, and this should be pointed 
out to Carl for R3, I think.

but can't put tuple! in struct directly...

Sometimes I wonder why such simple things are not implmented natively 
in REBOL.

Kib, I think, the answer is, that REBOL do a lot and then some more, 
but there are a few holes.

Yes, this one and repeating a string are essential to me. I may find 
other cases too :)

random also doesn't return 0.