[Bug-apl] Floating-point random number function

[Elias Mårtenson]

I had a need to have a function that does the same as monadic ?, but with
the difference that the resulting numbers not be integers, but floating
point.

Now, here's my attempt at creating such a function, I'd like to know if
this is the best way to achieve what I need:

∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍚ ?res+V×0
∇

Example:

* hrRand 3 2 ⍎ 10 100 5 (3 4 (2 2⍎5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
↓ 4.138685128
54.55782413 ┃
┃ 0.4543486424
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001 2.772781338
┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃ ↓3.185551114 3.13571477
┃┃┃
┃ ┃ ┃1.204617876
4.396324338┃┃┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃
┗∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523
9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

Regards,
Elias

[Christian Robert]

I think this is the best you can get, about 62 bits of randomness.

(64⍴2) ⊤⎕syl[20;2] ⍝ the largest 64 bits integer supported by gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

so, it's a bit less than 63 bits, say 62 bits for safety is Ok.

Note that (res+V×0) may wrap around.

Xtian.

I had a need to have a function that does the same as monadic ?, but with the difference that the resulting numbers not be integers, but floating point.
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍨ ?res+V×0
∇
* hrRand 3 2 ⍴ 10 100 5 (3 4 (2 2⍴5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
↓ 4.138685128 54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001 2.772781338 ┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃ ↓3.185551114 3.13571477 ┃┃┃
┃ ┃ ┃1.204617876 4.396324338┃┃┃
┃ ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523 9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
Re

[Elias Mårtenson]

Thanks. I'll stick with this for now then.

How would (res+V×0) wrap around, by the way?

Post by Christian Robert
I think this is the best you can get, about 62 bits of randomness.
(64⍎2) ⊀⎕syl[20;2] ⍝ the largest 64 bits integer supported by gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1
1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
so, it's a bit less than 63 bits, say 62 bits for safety is Ok.
Note that (res+V×0) may wrap around.
Xtian.

Post by Elias MÃ¥rtenson
I had a need to have a function that does the same as monadic ?, but with
the difference that the resulting numbers not be integers, but floating
point.
Now, here's my attempt at creating such a function, I'd like to know if
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍚ ?res+V×0
∇
* hrRand 3 2 ⍎ 10 100 5 (3 4 (2 2⍎5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━┓
↓ 4.138685128
54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001 2.772781338
┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃ ↓3.185551114
3.13571477 ┃┃┃
┃ ┃ ┃1.204617876 4
.396324338┃┃┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523
9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━┛
Regards,
Elias

[Christian Robert]

Post by Elias MÃ¥rtenson
Thanks. I'll stick with this for now then.
How would (res+V×0) wrap around, by the way?

Bad first reading, (res+V×0) does nothing, it add 0 to "res". How is it usefull ?

Xtian.

Post by Elias MÃ¥rtenson
I think this is the best you can get, about 62 bits of randomness.
(64⍴2) ⊤⎕syl[20;2] ⍝ the largest 64 bits integer supported by gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
so, it's a bit less than 63 bits, say 62 bits for safety is Ok.
Note that (res+V×0) may wrap around.
Xtian.
I had a need to have a function that does the same as monadic ?, but with the difference that the resulting numbers not be integers, but floating point.
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍨ ?res+V×0
∇
* hrRand 3 2 ⍴ 10 100 5 (3 4 (2 2⍴5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
↓ 4.138685128 <tel:[phone]> 54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001 <tel:[phone]> 2.772781338 ┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃ ↓3.185551114 <tel:[phone]> 3.13571477 ┃┃┃
┃ ┃ ┃1.204617876 4 <tel:[phone]%204>.396324338┃┃┃
┃ ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523 9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

[Elias Mårtenson]

The purpose of it is to preserve the structure of the argument, while
setting all values to MAXINT.

Is there a better way to achieve this?

Regards,
Elias

Post by Elias MÃ¥rtenson
Thanks. I'll stick with this for now then.
How would (res+V×0) wrap around, by the way?

Bad first reading, (res+V×0) does nothing, it add 0 to "res". How is it
usefull ?
Xtian.

Post by Elias MÃ¥rtenson
I think this is the best you can get, about 62 bits of randomness.
(64⍎2) ⊀⎕syl[20;2] ⍝ the largest 64 bits integer supported by
gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 0 0
1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
so, it's a bit less than 63 bits, say 62 bits for safety is Ok.
Note that (res+V×0) may wrap around.
Xtian.
I had a need to have a function that does the same as monadic ?,
but with the difference that the resulting numbers not be integers, but
floating point.
Now, here's my attempt at creating such a function, I'd like to
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍚ ?res+V×0
∇
* hrRand 3 2 ⍎ 10 100 5 (3 4 (2 2⍎5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━┓
↓ 4.138685128 <tel:[phone]>
54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001 <tel:[phone]>
2.772781338 ┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃ ↓3.185551114
<tel:[phone]> 3.13571477 ┃┃┃
┃ ┃ ┃1.204617876 4
<tel:[phone]%204>.396324338┃┃┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523
9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━┛
Regards,
Elias

[Christian Robert]

I don't know, your "(res+V×0)" is probably the way to go for that purpose, I'm not an expert but I understand what you mean.

I have an alias defined as:

proto←{↑0⍴⊂ ⍵}

that give me the prototype of the argument (use with: 24 QuadCR proto w). It will probably not help you but good to know.


Xtian.

The purpose of it is to preserve the structure of the argument, while setting all values to MAXINT.
Is there a better way to achieve this?
Regards,
Elias
Thanks. I'll stick with this for now then.
How would (res+V×0) wrap around, by the way?
Bad first reading, (res+V×0) does nothing, it add 0 to "res". How is it usefull ?
Xtian.
I think this is the best you can get, about 62 bits of randomness.
(64⍴2) ⊤⎕syl[20;2] ⍝ the largest 64 bits integer supported by gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
so, it's a bit less than 63 bits, say 62 bits for safety is Ok.
Note that (res+V×0) may wrap around.
Xtian.
I had a need to have a function that does the same as monadic ?, but with the difference that the resulting numbers not be integers, but floating point.
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍨ ?res+V×0
∇
* hrRand 3 2 ⍴ 10 100 5 (3 4 (2 2⍴5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
↓ 4.138685128 <tel:[phone]> <tel:[phone] <tel:[phone]>> 54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001 <tel:[phone]> <tel:[phone] <tel:[phone]>> 2.772781338 ┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃ ↓3.185551114 <tel:[phone]> <tel:[phone] <tel:[phone]>> 3.13571477 ┃┃┃
┃ ┃ ┃1.204617876 4 <tel:[phone]%204> <tel:[phone]%204>.396324338┃┃┃
┃ ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523 9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
Regards,
Elias

[Frederick Pitts]

Xtian,

Actually the function you present returns the type of the
argument, not the prototype, as per

Type <=> ↑0ρ⊂R

on page 46 of IBM's "APL2 Programming: Language Reference". The
prototype is the type of the first element of R, i.e.,

Prototype <=> ↑0⍴⊂↑R

Regards,

Fred

Post by Christian Robert
I don't know, your "(res+V×0)" is probably the way to go for that
purpose, I'm not an expert but I understand what you mean.
    proto←{↑0⍴⊂ ⍵}
that give me the prototype of the argument (use with: 24 QuadCR proto
w). It will probably not help you but good to know.
Xtian.

Post by Elias MÃ¥rtenson
The purpose of it is to preserve the structure of the argument,
while setting all values to MAXINT.
Is there a better way to achieve this?
Regards,
Elias
        Thanks. I'll stick with this for now then.
        How would (res+V×0) wrap around, by the way?
    Bad first reading, (res+V×0) does nothing, it add 0 to "res".
How is it usefull ?
    Xtian.
        On 30 June 2017 at 12:17, Christian Robert <christian.rober
             I think this is the best you can get, about 62 bits of
randomness.
                    (64⍴2) ⊤⎕syl[20;2] ⍝ the largest 64 bits
integer supported by gnu-apl
             0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0
0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0
             so, it's a bit less than 63 bits, say 62 bits for
safety is Ok.
             Note that (res+V×0) may wrap around.
             Xtian.
                 I had a need to have a function that does the same
as monadic ?, but with the difference that the resulting numbers
not be integers, but floating point.
                 Now, here's my attempt at creating such a
function, I'd like to know if this is the best way to achieve what
                 ∇ r←*hrRand* V ;res
                     ⍝⍝ Like monadic ?, but returns floating point
numbers
                     res ← ⎕SYL[19+⎕IO;1+⎕IO]
                     r ← V × res÷⍨ ?res+V×0
                 ∇
                 *      hrRand 3 2 ⍴ 10 100 5 (3 4 (2 2⍴5)) 1000*
                 ┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
                 ↓ 4.138685128 <tel:[phone]> <tel:[phone]
<tel:[phone]>>                                                 
  54.55782413 ┃
                 ┃  0.4543486424           ┏→━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
                 ┃                         ┃2.024528001
<tel:[phone]> <tel:[phone] <tel:[phone]>> 2.772781338
┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
                 ┃                         ┃                       
 ↓3.185551114 <tel:[phone]> <tel:[phone] <tel:[phone]>>
3.13571477 ┃┃┃
                 ┃                         ┃                       
 ┃1.204617876 4 <tel:[phone]%204>
<tel:[phone]%204>.396324338┃┃┃
                 ┃                         ┃                       
 ┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
                 ┃                         ┗∊━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
                 ┃634.0902523                                      
                9.353801479┃
                 ┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                 Regards,
                 Elias

[Christian Robert]

You are right !

Xtian.

Post by Frederick Pitts
Xtian,
Actually the function you present returns the type of the
argument, not the prototype, as per
Type <=> ↑0ρ⊂R
on page 46 of IBM's "APL2 Programming: Language Reference". The
prototype is the type of the first element of R, i.e.,
Prototype <=> ↑0⍴⊂↑R
Regards,
Fred

Post by Christian Robert
I don't know, your "(res+V×0)" is probably the way to go for that
purpose, I'm not an expert but I understand what you mean.
proto←{↑0⍴⊂ ⍵}
that give me the prototype of the argument (use with: 24 QuadCR proto
w). It will probably not help you but good to know.
Xtian.

Post by Elias MÃ¥rtenson
The purpose of it is to preserve the structure of the argument,
while setting all values to MAXINT.
Is there a better way to achieve this?
Regards,
Elias
Thanks. I'll stick with this for now then.
How would (res+V×0) wrap around, by the way?
Bad first reading, (res+V×0) does nothing, it add 0 to "res". How is it usefull ?
Xtian.
On 30 June 2017 at 12:17, Christian Robert <christian.rober
I think this is the best you can get, about 62 bits of randomness.
(64⍴2) ⊤⎕syl[20;2] ⍝ the largest 64 bits
integer supported by gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0
0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0
so, it's a bit less than 63 bits, say 62 bits for safety is Ok.
Note that (res+V×0) may wrap around.
Xtian.
I had a need to have a function that does the same
as monadic ?, but with the difference that the resulting numbers
not be integers, but floating point.
Now, here's my attempt at creating such a
function, I'd like to know if this is the best way to achieve what
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍨ ?res+V×0
∇
* hrRand 3 2 ⍴ 10 100 5 (3 4 (2 2⍴5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
↓ 4.138685128 <tel:[phone]> <tel:[phone]
<tel:[phone]>>
54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001
<tel:[phone]> <tel:[phone] <tel:[phone]>> 2.772781338
┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃
↓3.185551114 <tel:[phone]> <tel:[phone] <tel:[phone]>>
3.13571477 ┃┃┃
┃ ┃
┃1.204617876 4 <tel:[phone]%204>
<tel:[phone]%204>.396324338┃┃┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523
9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
Regards,
El

[Louis de Forcrand]

?0 would be a good extention wouldn't it? I don't have access to an interpreter but I would guess that it gives a domain error right now.

Cheers,
Louis

Post by Christian Robert
You are right !
Xtian.

Post by Frederick Pitts
Xtian,
Actually the function you present returns the type of the
argument, not the prototype, as per
Type <=> ↑0ρ⊂R
on page 46 of IBM's "APL2 Programming: Language Reference". The
prototype is the type of the first element of R, i.e.,
Prototype <=> ↑0⍴⊂↑R
Regards,
Fred

Post by Christian Robert
I don't know, your "(res+V×0)" is probably the way to go for that
purpose, I'm not an expert but I understand what you mean.
proto←{↑0⍴⊂ ⍵}
that give me the prototype of the argument (use with: 24 QuadCR proto
w). It will probably not help you but good to know.
Xtian.

Post by Elias MÃ¥rtenson
The purpose of it is to preserve the structure of the argument,
while setting all values to MAXINT.
Is there a better way to achieve this?
Regards,
Elias
Thanks. I'll stick with this for now then.
How would (res+V×0) wrap around, by the way?
Bad first reading, (res+V×0) does nothing, it add 0 to "res".
How is it usefull ?
Xtian.
On 30 June 2017 at 12:17, Christian Robert <christian.rober
I think this is the best you can get, about 62 bits of randomness.
(64⍴2) ⊤⎕syl[20;2] ⍝ the largest 64 bits
integer supported by gnu-apl
0 1 1 1 1 1 1 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 1 1 0 1 0
0 0 0 0 1 1 0 0 1 1 1 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0
so, it's a bit less than 63 bits, say 62 bits for safety is Ok.
Note that (res+V×0) may wrap around.
Xtian.
I had a need to have a function that does the same
as monadic ?, but with the difference that the resulting numbers
not be integers, but floating point.
Now, here's my attempt at creating such a
function, I'd like to know if this is the best way to achieve what
∇ r←*hrRand* V ;res
⍝⍝ Like monadic ?, but returns floating point numbers
res ← ⎕SYL[19+⎕IO;1+⎕IO]
r ← V × res÷⍨ ?res+V×0
∇
* hrRand 3 2 ⍴ 10 100 5 (3 4 (2 2⍴5)) 1000*
┏→━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
↓ 4.138685128 <tel:[phone]> <tel:[phone]
<tel:[phone]>>
54.55782413 ┃
┃ 0.4543486424 ┏→━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━┓┃
┃ ┃2.024528001
<tel:[phone]> <tel:[phone] <tel:[phone]>> 2.772781338
┏→━━━━━━━━━━━━━━━━━━━━━━┓┃┃
┃ ┃
↓3.185551114 <tel:[phone]> <tel:[phone] <tel:[phone]>>
3.13571477 ┃┃┃
┃ ┃
┃1.204617876 4 <tel:[phone]%204>
<tel:[phone]%204>.396324338┃┃┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━┛┃┃
┃ ┗∊━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━┛┃
┃634.0902523
9.353801479┃
┗∊∊━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
Regards,
Elias