बोर्डवॉक के खेल

भाग्य के खेलों को यादृच्छिकता के किसी स्रोत की ज़रूरत होती है। Factor की random वोकैबुलरी एक जेनेरिक शब्द, random, देती है, जो आप उसे जो भी सौंपें उसके हिसाब से ढल जाता है। इसके अलावा इसमें शफल करने और सैंपल लेने के लिए सहायक हैं, और टेस्ट के लिए यादृच्छिकता को दोबारा पैदा करने योग्य बनाने का एक तरीका भी है।

किसी शब्द को inline चिह्नित करना

इस अभ्यास के कुछ कार्य एक ऐसा शब्द बनाते हैं जो एक कोटेशन (एक [ … ] ब्लॉक) को आर्गुमेंट की तरह लेता है और उसे चलाता है। Factor में इस बारे में एक सख्त नियम है: जो शब्द किसी आर्गुमेंट के रूप में मिली कोटेशन को call करता है, उसे inline घोषित करना ज़रूरी है, और यह क्लोज़िंग ; के ठीक बाद inline लिखकर किया जाता है।

inline कंपाइलर को यह बताता है कि वह शब्द के बॉडी को हर कॉल साइट पर जोड़ दे, न कि उसे अलग से एक बार कंपाइल करे।

• कॉलर की कोटेशन सीधे अंदर जोड़ दी जाती है, इसलिए कोटेशन स्टैक पर जो भी छोड़ती है वह वापस कॉलर तक पहुँच जाता है, भले ही शब्द का अपना स्टैक इफेक्ट कोई आउटपुट घोषित न करता हो।

यहाँ एक छोटा शब्द है जो 10 पुश करता है और फिर उसे सौंपी गई कोटेशन चलाता है:

USING: kernel math prettyprint ;

: with-ten ( quot -- ) 10 swap call ; inline

इसका स्टैक इफेक्ट, ( quot -- ), कोई आउटपुट नहीं बताता, फिर भी इसे अलग-अलग इफेक्ट वाली दो कोटेशनों के साथ कॉल करने पर अलग-अलग नतीजे मिलते हैं, और सब कुछ वापस कॉलर तक पहुँचता है:

[ 1 + ] with-ten .        ! => 11   (quotation ( n -- n ): one value back)
[ dup 2 * ] with-ten . .  ! => 20
                          ! => 10   (quotation ( n -- n n ): two values back)

random: एक एलिमेंट

random (random में) अपने आर्गुमेंट के ऊपर जेनेरिक है:

random ( obj -- elt )

• अगर इसे पूर्णांक n दिया जाए, तो यह [0, n) में एक यादृच्छिक पूर्णांक लौटाता है:

USING: random ;

6 random .    ! 4   (a value from 0 to 5)

• अगर इसे एक सीक्वेंस दिया जाए, तो यह एक यादृच्छिक एलिमेंट लौटाता है:

{ "rock" "paper" "scissors" } random .    ! "paper"

साधारण पासा फेंकने के लिए आप रेंज को एक से बढ़ा देते हैं: 6 पर random 0 से 5 देता है, इसलिए 6 random 1 + 1 से 6 देता है।

कई वैल्यू निकालना

किसी तय संख्या में यादृच्छिक नतीजे इकट्ठा करने के लिए, replicate (sequences में) की मदद से एक कोटेशन दोहराइए:

replicate ( n quot -- seq )

USING: random sequences ;

3 [ 6 random 1 + ] replicate .    ! { 4 1 6 }   (three dice)

randomize: उसी जगह पर शफल करना

randomize (random में) उसी सीक्वेंस को लौटाता है जिसके एलिमेंट यादृच्छिक क्रम में हों:

randomize ( seq -- randomized )

{ 1 2 3 4 5 } randomize .    ! { 3 1 5 2 4 }

यह उसी जगह पर शफल करता है और वही सीक्वेंस लौटाता है, इसलिए अगर आपको मूल क्रम बनाए रखना है तो पहले clone कीजिए।

sample: कई अलग-अलग एलिमेंट

sample (random में) एक सीक्वेंस से n अलग-अलग एलिमेंट निकालता है, जैसे ताश के पत्ते बाँटना, जिसमें एक ही पत्ता दोबारा नहीं आता:

sample ( seq n -- seq' )

{ 10 20 30 40 50 } 3 sample .    ! { 40 10 30 }

सीक्वेंस में जितने एलिमेंट मौजूद हैं उससे ज़्यादा माँगना एक एरर है।

दोबारा पैदा करने योग्य यादृच्छिकता

डिफ़ॉल्ट रूप से random एक ग्लोबल जेनेरेटर से निकालता है जिसे सिस्टम क्लॉक से सीड किया जाता है, इसलिए हर बार चलाने पर नतीजा अलग आता है। टेस्ट के लिए, या जब भी आप ऐसा खेल चाहते हैं जिसे दोबारा खेला जा सके, किसी तय सीड वाले जेनेरेटर को बाँधिए।

<mersenne-twister> (random.mersenne-twister में) एक पूर्णांक सीड से एक जेनेरेटर बनाता है, और with-random (random में) उस जेनेरेटर को सेट करके एक कोटेशन चलाता है:

<mersenne-twister> ( seed -- rnd )
with-random        ( rnd quot -- )

USING: random random.mersenne-twister ;

42 <mersenne-twister> [ 6 random 1 + ] with-random .
! always the same value for seed 42

कोटेशन के अंदर की हर चीज़, यानी random, randomize, sample, सीड किए गए जेनेरेटर से ही निकालती है, इसलिए वही सीड हमेशा वही नतीजा दोहराती है।

जो शब्द किसी कोटेशन को आर्गुमेंट की तरह लेता है और उसे with-random के ज़रिए चलाता है, वह उस नियम के अंतर्गत आता है जो किसी शब्द को inline चिह्नित करना वाले हिस्से में बताया गया है: with-random अंत में उस कोटेशन को call करता है, इसलिए ऐसे रैपर को inline चिह्नित करना ज़रूरी है।