Erlang 21

rand




erlang

rand

मॉड्यूल

हाशिया

मॉड्यूल सारांश

छद्म यादृच्छिक संख्या पीढ़ी।

विवरण

यह मॉड्यूल एक छद्म यादृच्छिक संख्या जनरेटर प्रदान करता है। मॉड्यूल में कई एल्गोरिदम शामिल हैं। वर्दी वितरण एल्गोरिदम xoroshiro116+ and xorshift1024* algorithms by Sebastiano Vigna. उपयोग करते हैं xoroshiro116+ and xorshift1024* algorithms by Sebastiano Vigna. समान वितरण एल्गोरिथ्म के शीर्ष पर Ziggurat Method by Marsaglia and Tsang सामान्य वितरण एल्गोरिथ्म Ziggurat Method by Marsaglia and Tsang का उपयोग करता है।

कुछ एल्गोरिदम के लिए, समानांतर गणनाओं के लिए गैर-अतिव्यापी अनुक्रम उत्पन्न करने के लिए कूद कार्य प्रदान किए जाते हैं। जंप फ़ंक्शंस नए राज्यों की गणना के लिए बार-बार कॉल करने के लिए गणना के बराबर प्रदर्शन करते हैं।

निम्नलिखित एल्गोरिदम प्रदान किए गए हैं:

exrop

Xoroshiro116 +, 58 बिट्स परिशुद्धता और 2 ^ 116-1 की अवधि

कूद समारोह: 2 ^ 64 कॉल के बराबर

exs1024s

Xorshift1024 *, 64 बिट्स सटीक और 2 ^ 1024-1 की अवधि

कूद समारोह: 2 ^ 512 कॉल के बराबर

exsp

Xorshift116 +, 58 बिट्स परिशुद्धता और 2 ^ 116-1 की अवधि

कूद समारोह: 2 ^ 64 कॉल के बराबर

यह पिछले डिफ़ॉल्ट एल्गोरिथ्म का एक सही संस्करण है, जिसे अब Xoroshiro116 + ( exrop ) द्वारा सुपरक्यूट किया गया है। चूंकि कोई देशी 58 बिट घूर्णन निर्देश नहीं है, इसलिए यह एल्गोरिथ्म exrop तुलना में थोड़ा (<15%) तेज़ी से exrop algorithms' homepage देखें।

डिफ़ॉल्ट एल्गोरिथ्म exrop (Xoroshiro116 +) है। यदि एक विशिष्ट एल्गोरिथ्म की आवश्यकता है, तो राज्य को आरंभीकृत करने के लिए हमेशा seed/1 का उपयोग करना सुनिश्चित करें।

अनजाने (पुराने) एल्गोरिदम को हटा दिया गया है लेकिन फिर भी उन पर निर्भर पुराने कोड को लागू किया गया है जो पहले की तरह ही छद्म यादृच्छिक अनुक्रम उत्पन्न करेगा।

ध्यान दें

अब अनिर्धारित एल्गोरिदम के कार्यान्वयन में कई समस्याएं थीं, यही वजह है कि उन्हें हटा दिया गया है। नए एल्गोरिदम थोड़े धीमे हैं लेकिन इनमें ये समस्याएँ नहीं हैं:

यूनिफ़ॉर्म पूर्णांक श्रेणियों में संभाव्यता वितरण में एक तिरछा था जो छोटी श्रेणियों के लिए ध्यान देने योग्य नहीं था लेकिन जनरेटर की सटीकता से कम बड़ी श्रेणियों के लिए कम संख्या का उत्पादन करने की संभावना उच्च के लिए संभावना से दोगुना हो सकती है।

यूनिफ़ॉर्म पूर्णांक जनरेटर की सटीकता से अधिक या उसके बराबर होता है, जिसमें फ़्लोटिंग पॉइंट फ़ॉलबैक का उपयोग किया जाता है, जो केवल 52 बिट्स के साथ गणना की जाती है जो अनुरोधित सीमा से छोटी होती है और इसलिए अनुरोधित सीमा में सभी संख्याएँ उत्पादन के लिए भी संभव नहीं थीं।

यूनिफ़ॉर्म फ़्लैट में एक समान रूप से घनत्व था, इसलिए छोटे मानों में 0.5 से कम का अंतराल कम हो गया था, क्योंकि उत्पन्न मान 0.0 से कम हो गया था, हालांकि अभी भी समान रूप से बड़े सबरंगों के लिए समान रूप से वितरित किया गया है। नए एल्गोरिदम समान रूप से वितरित एन / 2.0 ^ (- 53) फॉर्म पर समान रूप से वितरित फ़्लोट्स का उत्पादन करते हैं इसलिए समान रूप से स्थान दिया गया है।

जब भी एक यादृच्छिक संख्या का अनुरोध किया जाता है, एक राज्य का उपयोग इसकी गणना करने के लिए किया जाता है और एक नया राज्य निर्मित होता है। राज्य या तो निहित हो सकता है या एक स्पष्ट तर्क और वापसी मूल्य हो सकता है।

अंतर्निहित स्थिति वाले कार्य वर्तमान अवस्था को याद रखने के लिए प्रक्रिया शब्दकोश चर rand_seed का उपयोग करते हैं।

यदि कोई प्रक्रिया पहले एक बीज निर्धारित किए बिना uniform/0 , uniform/1 या uniform_real/0 , तो seed/1 को डिफ़ॉल्ट एल्गोरिथ्म के साथ स्वचालित रूप से कहा जाता है और एक गैर-निरंतर बीज बनाता है।

स्पष्ट स्थिति वाले कार्य कभी भी प्रक्रिया शब्दकोश का उपयोग नहीं करते हैं।

उदाहरण:

सरल उपयोग; यदि पहले से नहीं किया गया है तो एक गैर-स्थिर बीज के साथ डिफ़ॉल्ट एल्गोरिथ्म बनाता है और बीज देता है:

R0 = rand:uniform(),
R1 = rand:uniform(),

एक निर्दिष्ट एल्गोरिथ्म का उपयोग करें:

_ = rand:seed(exs1024s),
R2 = rand:uniform(),

एक निरंतर बीज के साथ एक निर्दिष्ट एल्गोरिथ्म का उपयोग करें:

_ = rand:seed(exs1024s, {123, 123534, 345345}),
R3 = rand:uniform(),

एक गैर-निरंतर बीज के साथ कार्यात्मक एपीआई का उपयोग करें:

S0 = rand:seed_s(exrop),
{R4, S1} = rand:uniform_s(S0),

पाठ्यपुस्तक मूल रूप बॉक्स-मुलर मानक सामान्य विचलन

R5 = rand:uniform_real(),
R6 = rand:uniform(),
SND0 = math:sqrt(-2 * math:log(R5)) * math:cos(math:pi() * R6)

मानक सामान्य विचलन बनाएँ:

{SND1, S2} = rand:normal_s(S1),

औसत -3 और विचरण 0.5 के साथ एक सामान्य विचलन बनाएँ:

{ND0, S3} = rand:normal_s(-3, 0.5, S2),
ध्यान दें

अंतर्निहित रैंडम संख्या जनरेटर एल्गोरिदम क्रिप्टोग्राफिक रूप से मजबूत नहीं हैं। यदि क्रिप्टोग्राफिक रूप से मजबूत यादृच्छिक संख्या जनरेटर की आवश्यकता है, तो crypto:rand_seed/0 जैसे कुछ का उपयोग करें crypto:rand_seed/0

इन सभी जनरेटर के लिए अन्य बिट्स की तुलना में सबसे कम बिट (ओं) को थोड़ा कम यादृच्छिक व्यवहार मिला है। exrop (और exsp ) के लिए 1 बिट, और exs1024s लिए 3 बिट्स। उदाहरण के लिए देखें Xoroshiro128+ जनरेटर स्रोत कोड में स्पष्टीकरण:

Beside passing BigCrush, this generator passes the PractRand test suite
up to (and included) 16TB, with the exception of binary rank tests,
which fail due to the lowest bit being an LFSR; all other bits pass all
tests. We suggest to use a sign test to extract a random Boolean value.

यदि यह एक समस्या है; इस तरह से कुछ बूलियन उपयोग उत्पन्न करने के लिए:

(rand:uniform(16) > 8)

और एक सामान्य श्रेणी के लिए, exrop लिए N = 1 के exrop , और exrop N = 3 exs1024s लिए N = 3 :

(((rand:uniform(Range bsl N) - 1) bsr N) + 1)

इस मॉड्यूल में फ़्लोटिंग पॉइंट जनरेटिंग फ़ंक्शन पूर्णांक से परिवर्तित करते समय सबसे कम बिट्स को बर्बाद करते हैं ताकि वे इस रोड़ा से बचें।

जानकारी का प्रकार

builtin_alg() =
exs64 | exsplus | exsp | exs1024 | exs1024s | exrop

alg() = builtin_alg() | atom()
alg_handler() =
#{type := alg() ,
bits => integer() >= 0,
weak_low_bits => integer() >= 0,
max => integer() >= 0,
next :=
fun(( alg_state() ) -> {integer() >= 0, alg_state() }),
uniform => fun(( state() ) -> {float(), state() }),
uniform_n =>
fun((integer() >= 1, state() ) -> {integer() >= 1, state() }),
jump => fun(( state() ) -> state() )}

एल्गोरिथम-निर्भर स्थिति।

export_state() = { alg() , alg_state() }

एल्गोरिथम-आश्रित स्थिति जिसे फ़ाइल में मुद्रित या सहेजा जा सकता है।

exs64_state()

एल्गोरिदम विशिष्ट आंतरिक स्थिति

exsplus_state()

एल्गोरिदम विशिष्ट आंतरिक स्थिति

exs1024_state()

एल्गोरिदम विशिष्ट आंतरिक स्थिति

exrop_state()

एल्गोरिदम विशिष्ट आंतरिक स्थिति

निर्यात

Export_seed () -> अपरिभाषित | export_state()

किसी बाहरी स्वरूप में यादृच्छिक संख्या स्थिति देता है। seed/1 साथ प्रयोग किया जाना seed/1

Export_seed_s (राज्य :: state() ) -> export_state()

किसी बाहरी स्वरूप में रैंडम नंबर जनरेटर स्थिति देता है। seed/1 साथ प्रयोग किया जाना seed/1

कूद () -> NewState :: state()

प्रक्रिया शब्दकोश में राज्य के लिए कूद गणना करने के बाद राज्य को लौटाता है।

यह फ़ंक्शन एक not_implemented त्रुटि अपवाद उत्पन्न करता है जब प्रक्रिया शब्दकोश में राज्य में निर्दिष्ट एल्गोरिथ्म के लिए कूद फ़ंक्शन लागू नहीं किया जाता है।

छलांग (राज्य :: state() ) -> नई state() :: state()

दिए गए राज्य के लिए कूद गणना करने के बाद राज्य लौटाता है।

यह फ़ंक्शन राज्य में निर्दिष्ट एल्गोरिथ्म के लिए जंप फ़ंक्शन लागू नहीं होने पर एक not_implemented त्रुटि अपवाद उत्पन्न करता है।

सामान्य () -> फ्लोट ()

मानक सामान्य विचलन फ्लोट लौटाता है (मतलब 0 है और मानक विचलन 1 है) और प्रक्रिया शब्दकोश में राज्य को अद्यतन करता है।

सामान्य (माध्य :: संख्या) (), भिन्न :: संख्या ()) -> नाव ()

एक सामान्य एन (मीन, वैरियन) को लौटाता है और प्रक्रिया शब्दकोश में राज्य को अद्यतन करता है।

normal_s (स्थिति :: state() ) -> {फ्लोट (), NewState :: state() }

एक निर्दिष्ट राज्य के लिए रिटर्न, एक मानक सामान्य विचलन फ्लोट (अर्थात, 0 है और मानक विचलन 1 है) और एक नया राज्य।

normal_s (माध्य :: संख्या) (),
भिन्न :: संख्या (),
state() ० :: state() ) ->
{फ्लोट (), NewS :: state() }

रिटर्न, एक निर्दिष्ट राज्य के लिए, एक सामान्य एन (मीन, वैरियन) फ्लोट और एक नया राज्य।

बीज (AlgOrStateOrExpState ::
builtin_alg() | state() | export_state() ) ->
state()

AlgOrStateOrExpState एल्गोरिथ्म और समय-निर्भर डेटा के साथ यादृच्छिक संख्या उत्पन्न करता है यदि AlgOrStateOrExpState एक एल्गोरिथ्म है।

अन्यथा प्रक्रिया शब्दकोश में निर्यात किए गए बीज को फिर से बनाता है, और राज्य को वापस करता है। export_seed/0 भी देखें।

बीज (Alg :: builtin_alg() ,
बीज :: {पूर्णांक (), पूर्णांक (), पूर्णांक ()}) ->
state()

प्रक्रिया शब्दकोश में निर्दिष्ट एल्गोरिथ्म और पूर्णांकों के साथ यादृच्छिक संख्या पीढ़ी को बीज देता है और राज्य को वापस करता है।

seed_s (AlgOrStateOrExpState ::
builtin_alg() | state() | export_state() ) ->
state()

AlgOrStateOrExpState एल्गोरिथ्म और समय-निर्भर डेटा के साथ यादृच्छिक संख्या उत्पन्न करता है यदि AlgOrStateOrExpState एक एल्गोरिथ्म है।

अन्यथा निर्यात किए गए बीज को फिर से बनाता है और राज्य को वापस करता है। export_seed/0 भी देखें।

seed_s (Alg :: builtin_alg() ,
बीज :: {पूर्णांक (), पूर्णांक (), पूर्णांक ()}) ->
state()

निर्दिष्ट एल्गोरिथ्म और पूर्णांक के साथ यादृच्छिक संख्या पीढ़ी को बीज देता है और राज्य को वापस करता है।

वर्दी () -> एक्स :: फ्लोट ()

एक यादृच्छिक फ्लोट को समान रूप से मान श्रेणी में वितरित किया जाता है 0.0 =< X < 1.0 और प्रक्रिया शब्दकोश में राज्य को अपडेट करता है।

उत्पन्न संख्याएँ फॉर्म N * 2.0 ^ (- 53) पर हैं, अर्थात; समान रूप से अंतराल में फैला हुआ।

चेतावनी

यह फ़ंक्शन ठीक 0.0 वापस आ सकता है जो कुछ अनुप्रयोगों के लिए घातक हो सकता है। यदि वह अवांछित है तो आप अंतराल 0.0 < X =< 1.0 प्राप्त करने के लिए (1.0 - rand:uniform()) का उपयोग कर सकते हैं या इसके बजाय uniform_real/0 उपयोग कर uniform_real/0

यदि न तो समापन बिंदु वांछित है, तो आप इस तरह से परीक्षण और पुनः प्रयास कर सकते हैं:

my_uniform() ->
    case rand:uniform() of
        0.0 -> my_uniform();
	X -> X
    end
end.
वर्दी_लंग () -> एक्स :: फ्लोट ()

मान श्रेणी DBL_MIN =< X < 1.0 में समान रूप से वितरित एक यादृच्छिक फ्लोट लौटाता है और प्रक्रिया शब्दकोश में राज्य को अपडेट करता है।

वैचारिक रूप से, एक यादृच्छिक वास्तविक संख्या R , अंतराल 0 =< R < 1 से उत्पन्न होती है और फिर IEEE 754 डबल सटीक प्रारूप में सामान्यीकृत संख्या के निकटतम गोल को वापस कर दिया जाता है।

ध्यान दें

इस फ़ंक्शन से उत्पन्न संख्याओं को नियमित uniform/0 तुलना में छोटी संख्याओं के लिए बेहतर ग्रैन्युलैरिटी मिली है क्योंकि मंटिसा में सभी बिट्स यादृच्छिक हैं। यह गुण, इस तथ्य के साथ संयोजन में कि शून्य को कभी भी वापस नहीं किया जाता है, उदाहरण के लिए 1.0 / X या math:log(X) करने के लिए उपयोगी है।

अधिक स्पष्टीकरण के लिए uniform_real_s/1 देखें।

वर्दी (एन :: पूर्णांक) (> = 1) -> एक्स :: पूर्णांक ()> = 1

एक निर्दिष्ट पूर्णांक N >= 1 लिए रिटर्न, एक यादृच्छिक पूर्णांक समान रूप से मूल्य सीमा 1 =< X =< N में वितरित किया जाता है और प्रक्रिया शब्दकोश में राज्य को अपडेट करता है।

वर्दी_एस (राज्य :: state() ) -> {एक्स :: फ्लोट (), न्यूस्टेट :: state() }

एक निर्दिष्ट राज्य के लिए रिटर्न, यादृच्छिक फ़्लोट समान रूप से मान श्रेणी में वितरित किया जाता है 0.0 =< X < 1.0 और एक नया राज्य।

उत्पन्न संख्याएँ फॉर्म N * 2.0 ^ (- 53) पर हैं, अर्थात; समान रूप से अंतराल में फैला हुआ।

चेतावनी

यह फ़ंक्शन ठीक 0.0 वापस आ सकता है जो कुछ अनुप्रयोगों के लिए घातक हो सकता है। यदि यह अवांछित है तो आप अंतराल 0.0 < X =< 1.0 प्राप्त करने के लिए (1.0 - rand:uniform(State)) का उपयोग कर सकते हैं, या इसके बजाय uniform_real_s/1 उपयोग कर uniform_real_s/1

यदि न तो समापन बिंदु वांछित है, तो आप इस तरह से परीक्षण और पुनः प्रयास कर सकते हैं:

my_uniform(State) ->
    case rand:uniform(State) of
        {0.0, NewState} -> my_uniform(NewState);
	Result -> Result
    end
end.
यूनिफ़ॉर्म_लू_ (राज्य :: state() ) ->
{एक्स :: फ्लोट (), न्यूस्टेट :: state() }

एक निर्दिष्ट राज्य के लिए रिटर्न, एक यादृच्छिक फ़्लोट समान रूप से मूल्य श्रेणी DBL_MIN =< X < 1.0 में वितरित किया जाता है और प्रक्रिया शब्दकोश में राज्य को अपडेट करता है।

वैचारिक रूप से, एक यादृच्छिक वास्तविक संख्या R , अंतराल 0 =< R < 1 से उत्पन्न होती है और फिर IEEE 754 डबल सटीक प्रारूप में सामान्यीकृत संख्या के निकटतम गोल को वापस कर दिया जाता है।

ध्यान दें

इस फ़ंक्शन से उत्पन्न संख्याओं को नियमित uniform_s/1 तुलना में छोटी संख्या के लिए बेहतर ग्रैन्युलैरिटी मिली है क्योंकि uniform_s/1 सभी बिट्स यादृच्छिक हैं। यह गुण, इस तथ्य के साथ संयोजन में कि शून्य को कभी भी वापस नहीं किया जाता है, उदाहरण के लिए 1.0 / X या math:log(X) करने के लिए उपयोगी है।

यह अवधारणा बताती है कि शून्य को प्राप्त करने की संभावना बेहद कम है; इतना कम कि यह फ़ंक्शन वास्तव में कभी भी शून्य न लौटने की गारंटी है। सबसे छोटी संख्या जिसे वह वापस कर सकता है वह DBL_MIN , जो 2.0 ^ (- 1022) है।

इस फ़ंक्शन विवरण के शीर्ष पर बताई गई मूल्य सीमा तकनीकी रूप से सही है, लेकिन 0.0 =< X < 1.0 उत्पन्न संख्याओं के सांख्यिकीय वितरण का बेहतर विवरण है। सिवाय इसके कि ठीक 0.0 कभी नहीं लौटाया जाता है, जो सांख्यिकीय रूप से निरीक्षण करना संभव नहीं है।

उदाहरण के लिए; सभी उप श्रेणियों के लिए N*2.0^(-53) =< X < (N+1)*2.0^(-53) जहां 0 =< integer(N) < 2.0^53 संभावना समान है। uniform_s/1 द्वारा उत्पन्न संख्याओं के रूप के साथ तुलना करें।

छोटी संख्या के लिए अतिरिक्त यादृच्छिक बिट्स उत्पन्न करने के लिए थोड़ा सा प्रदर्शन होता है। यह कार्य नियमित uniform_s/1 की तुलना में लगभग 20% धीमा है

वर्दी_एस (एन :: पूर्णांक) (> = 1, राज्य :: state() ) ->
{X :: पूर्णांक ()> = 1, NewState :: state() }

रिटर्न, एक निर्दिष्ट पूर्णांक N >= 1 और एक राज्य के लिए, एक यादृच्छिक पूर्णांक समान रूप से मूल्य सीमा 1 =< X =< N और एक नए राज्य में वितरित किया जाता है।