Introduced in the 1977 ANSI M[UMPS] language standard.
This function returns a random (integer) value.
(The notation [0..n) means these examples that the result is an integer value between 0 (inclusive) and n (exclusive).)
| Reference | Value | |
|---|---|---|
| $RANDOM(N) | (0, N) | |
| $RANDOM(2) | 1 or 0 | |
| $RANDOM(2.3) | 1 or 0 | |
| $RANDOM(1) | 0 | |
| $RANDOM(0) | Error (M3) | |
| $RANDOM(-1) | Error (M3) |
A common mistake is to write code like
... Kill Selected For i=1:1:max Do . Set ok=0 For Do Quit:ok . . Set r=$Random(max)+1 . . Set:'$Data(Selected(r)) ok=r . . Quit . Set result(i)=ok . Set Selected(ok)=1 . Quit ...
This code will repeat a random selection until it finds an
element that hasn't been selected before, and typically,
one doesn't even notice that it may take multiple attempts to
find an "not-yet-selected" element until about 90% of the
elements have been selected. After that, the time that is
spent in the multiple iterations to find a "not-yet-selected"
element typically tend to consume noticeable amounts of time.
In short, it does pay to avoid multiple attempts to find a
"not-yet-selected" element.
In true keeping with the spirit of a Standards Development Committee, the amount of attention paid to a topic should be in reverse proportion to the importance of the topic.
So... since many people feel that $Random is the least important function in the standardized suite, here goes:
To shuffle a deck of cards:
Set DeckOne="" For i=1:1:52 Set DeckOne=DeckOne_$Char(i) Set DeckTwo="" For i=52:-1:1 Do . Set card=$Random(i)+1 . Set DeckTwo=DeckTwo_$ASCII(DeckOne,card) . Set $Extract(DeckOne,card)="" . Quit Set suites="Clubs Hearts Clovers Diamonds" Set cards="Ace 2 3 4 5 6 7 8 9 10 Jack Queen King" For i=1:1:52 Do . Set code=$ASCII(DeckTwo,i)-1 . Set suite=code\13+1,card=code#13+1 . Write !,$Piece(cards," ",card), . Write " of ",$Piece(suites," ",suite) . Quit Quit
When displaying the shuffled deck, internal code numbers 1
through 13 correspond to the suite of Clubs, 14 through 26
the suite of Hearts, 27 through 39 the Clovers, and 40
through 52 the Diamonds.
Within each suite, the first element corresponds to the Ace,
and the thirteenth to the King.
Note that one (random) card is removed from DeckOne at each step of the loop, and is added to DeckTwo. Thus, the random selection can never select the same card twice.
Of course, the shuffle can also be accomplished by using
one single variable that holds both the original deck of
cards, and the cards that still need to be randomized.
The trick is to interchange the first card with a randomly
selected one, then the second one, etcetera.
Note that the loop only goes to 51 in this case, because
once 51 cards have been selected, the remaining one doesn't
need the random generator to be able to find it anymore...
(nor does it need to be interchanged with any other card).
Set Deck="" For i=1:1:52 Set Deck=Deck_$Char(i) Set n=52 For i=1:1:51 Do . Set r=$Random(n) . Set n=n-1 . Set temp=$Extract(Deck,i+r) . Set $Extract(Deck,i+r)=$Extract(Deck,i) . Set $Extract(Deck,i)=temp . Quit Quit
The above approach works fine as long as the collection of
elements has a predictably small size (particularly: less
than the number of characters in the character-set).
So, with the 7-bit ASCII set, this will work uip to 127 elements,
with the 8-bit ASCII, it will work up to 255 elements, with
with Unicode, it will work up to 65,535 elements, and with
ISO-10646 it would work up to 2**32-1 elements
(4,294,967,295), but there currently aren't any known
complete implementations of that character-set.
So, for large collections, it will be necessary to rely on MUMPS's strong point: the sparse global variable.
One approach could be to do it like this:
Kill Set max=verymany For i=1:1:max Set ^GloVar(i)=0 For i=max:-1:1 Do . Set done=0,t="",target=$Random(i)+1 . Set count=0 For Do Quit:done . . Set t=$Order(^GloVar(t)) . . Set:t'="" count=count+1 . . If target=count Set done=1 Kill ^GloVar(t) . . Quit . Write !,"Element number "_(max-i+1)," = ",t . Quit
Or, making it a tad faster:
Kill Set max=verymany For n=1:1:max Set ^GloVar(n)="" For i=max:-1:1 Do . Set r=$Random(i)+1 . Set n="" For k=1:1:r Set n=$Order(^GloVar(n)) . Write !,"Element number "_(max-i+1)," = ",n . Kill ^GloVar(n) . Quit
And, making it a lot faster by removing the need for the $Order altogether:
Kill Set max=verymany For n=1:1:max Set ^GloVar(n)="" Set n=max For i=1:1:max-1 Do . Set r=$Random(n) . Set n=n-1 . Set temp=^GloVar(i+r) . Set ^GloVar(i+r)=^GloVar(i) . Set ^GloVar(i)=temp . Quit
Examples with naked references:
$RANDOM(VALUE)
SET ^ABC(1,2)="reset naked indicator"
; Naked indicator is now ^ABC(1,
SET ^(3,4)=$RANDOM(^(5,6))
; 1. fetch ^(5,6) = ^ABC(1,5,6)
; 2. store ^(3,4) = ^ABC(1,5,3,4)
; Naked indicator is now: ^ABC(1,5,3,
This document is © Ed de Moel, 1995-2005.
It is part of a book by Ed de Moel that is published under
the title "M[UMPS] by Example" (ISBN 0-918118-42-5).
Printed copies of the book are no longer available.