math - महत - "यादृच्छिकता" को समझना




सांख्यिकी की प्रकृति (18)

मैं इसके चारों ओर अपना सिर नहीं ले सकता, जो अधिक यादृच्छिक है?

rand()

या

rand() * rand()

मुझे यह एक असली मस्तिष्क टीज़र मिल रहा है, क्या आप मेरी मदद कर सकते हैं?

संपादित करें:

सहजता से मुझे पता है कि गणितीय उत्तर यह होगा कि वे समान रूप से यादृच्छिक हैं, लेकिन मैं मदद नहीं कर सकता लेकिन सोच सकता हूं कि यदि आप दो बार गुणा करते हैं तो आप दो बार यादृच्छिक संख्या एल्गोरिदम चलाते हैं तो आप बस कुछ करने से ज्यादा यादृच्छिक बनायेंगे यह एक बार


बस एक स्पष्टीकरण

यद्यपि पिछले उत्तर सही होते हैं जब भी आप छद्म-यादृच्छिक चर या उसके गुणा की यादृच्छिकता को खोजने की कोशिश करते हैं, आपको अवगत होना चाहिए कि यादृच्छिक () आमतौर पर समान रूप से वितरित किया जाता है, यादृच्छिक () * यादृच्छिक () नहीं है।

उदाहरण

यह एक छद्म-यादृच्छिक चर के माध्यम से नकली एक समान यादृच्छिक वितरण नमूना है :

        BarChart[BinCounts[RandomReal[{0, 1}, 50000], 0.01]]

हालांकि यह वितरण दो यादृच्छिक चर गुणा करने के बाद मिलता है:

        BarChart[BinCounts[Table[RandomReal[{0, 1}, 50000] * 
                                 RandomReal[{0, 1}, 50000], {50000}], 0.01]]

तो, दोनों "यादृच्छिक" हैं, लेकिन उनका वितरण बहुत अलग है।

एक और उदाहरण

जबकि 2 * रैंडम () समान रूप से वितरित किया गया है:

        BarChart[BinCounts[2 * RandomReal[{0, 1}, 50000], 0.01]]

यादृच्छिक () + यादृच्छिक () नहीं है!

        BarChart[BinCounts[Table[RandomReal[{0, 1}, 50000] + 
                                 RandomReal[{0, 1}, 50000], {50000}], 0.01]]

केंद्रीय सीमा प्रमेय

केन्द्रीय सीमा प्रमेय बताता है कि रैंडम () की राशि सामान्य वृद्धि के रूप में होती है क्योंकि शब्दों में वृद्धि होती है।

आपको केवल चार पदों के साथ मिलता है:

BarChart[BinCounts[Table[RandomReal[{0, 1}, 50000] + RandomReal[{0, 1}, 50000] +
                   Table[RandomReal[{0, 1}, 50000] + RandomReal[{0, 1}, 50000],
                   {50000}],
         0.01]]  

और यहां आप 1, 2, 4, 6, 10 और 20 को समान रूप से वितरित यादृच्छिक चर जोड़कर एक वर्दी से सामान्य वितरण तक सड़क देख सकते हैं:

संपादित करें

कुछ क्रेडिट

टिप्पणियों में इंगित करने के लिए थॉमस अहले के लिए धन्यवाद कि पिछले दो छवियों में दिखाए गए संभाव्यता वितरण इरविन-हॉल वितरण के रूप में जाना जाता है

अपने अद्भुत टूटे [] समारोह के लिए Heike लिए धन्यवाद


  1. There is no such thing as more random. It is either random or not. Random means "hard to predict". It does not mean non-deterministic. Both random() and random() * random() are equally random if random() is random. Distribution is irrelevant as far as randomness goes. If a non-uniform distribution occurs, it just means that some values are more likely than others; they are still unpredictable.

  2. Since pseudo-randomness is involved, the numbers are very much deterministic. However, pseudo-randomness is often sufficient in probability models and simulations. It is pretty well known that making a pseudo-random number generator complicated only makes it difficult to analyze. It is unlikely to improve randomness; it often causes it to fail statistical tests.

  3. The desired properties of the random numbers are important: repeatability and reproducibility, statistical randomness, (usually) uniformly distributed, and a large period are a few.

  4. Concerning transformations on random numbers: As someone said, the sum of two or more uniformly distributed results in a normal distribution. This is the additive central limit theorem. It applies regardless of the source distribution as long as all distributions are independent and identical. The multiplicative central limit theorem says the product of two or more independent and indentically distributed random variables is lognormal. The graph someone else created looks exponential, but it is really lognormal. So random() * random() is lognormally distributed (although it may not be independent since numbers are pulled from the same stream). This may be desirable in some applications. However, it is usually better to generate one random number and transform it to a lognormally-distributed number. Random() * random() may be difficult to analyze.

For more information, consult my book at www.performorama.org. The book is under construction, but the relevant material is there. Note that chapter and section numbers may change over time. Chapter 8 (probability theory) -- sections 8.3.1 and 8.3.3, chapter 10 (random numbers).


"यादृच्छिकता" के बारे में कुछ चीजें प्रति-अंतर्ज्ञानी हैं।

rand() फ्लैट वितरण को मानते हुए, निम्नलिखित आपको गैर-फ्लैट वितरण प्राप्त करेंगे:

  • उच्च पूर्वाग्रह: sqrt(rand(range^2))
  • मध्य में पूर्वाग्रह चोटी: (rand(range) + rand(range))/2
  • कम: पूर्वाग्रह: range - sqrt(rand(range^2))

विशिष्ट पूर्वाग्रह घटता बनाने के कई अन्य तरीके हैं। मैंने rand() * rand() का त्वरित परीक्षण किया और यह आपको एक बहुत ही गैर-रैखिक वितरण प्राप्त करता है।


अधिकांश रैंड () कार्यान्वयन में कुछ अवधि होती है। Ie कुछ बड़ी संख्या में कॉल के बाद अनुक्रम दोहराता है। rand() * rand() के आउटपुट का क्रम आधे समय में दोहराया जाता है, इसलिए यह उस अर्थ में "कम यादृच्छिक" है।

इसके अलावा, सावधान निर्माण के बिना, यादृच्छिक मूल्यों पर अंकगणित प्रदर्शन कम यादृच्छिकता का कारण बनता है। उपरोक्त एक पोस्टर " rand() + rand() + rand() ..." (के टाइम्स, कहें) जो वास्तव में मूल्यों को rand() रिटर्न की श्रेणी के औसत मूल्य के रूप में rand() है। (यह उस मतलब के बारे में कदम सममित के साथ एक यादृच्छिक चलना है।)

Concreteness के लिए मान लें कि आपकी रैंड () फ़ंक्शन श्रेणी [0,1) में समान रूप से वितरित यादृच्छिक वास्तविक संख्या देता है। (हां, यह उदाहरण अनंत परिशुद्धता की अनुमति देता है। इससे परिणाम नहीं बदलेगा।) आपने कोई विशेष भाषा नहीं चुनी है और अलग-अलग भाषाएं अलग-अलग चीजें कर सकती हैं, लेकिन निम्नलिखित विश्लेषण में रैंड के किसी भी गैर-प्रतिकूल कार्यान्वयन के लिए संशोधन के साथ है ( )। उत्पाद rand() * rand() सीमा [0,1) में भी है लेकिन अब समान रूप से वितरित नहीं किया गया है। वास्तव में, अंतराल [1 / 4,1) के रूप में उत्पाद अंतराल [0,1 / 4) में होने की संभावना है। अधिक गुणा परिणाम शून्य को आगे भी आगे बढ़ाएगा। इससे परिणाम अधिक अनुमानित हो जाता है। व्यापक स्ट्रोक में, अधिक अनुमानित == कम यादृच्छिक।

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


जिस अवधारणा को आप ढूंढ रहे हैं वह "एन्ट्रॉपी" है, बिट्स की एक स्ट्रिंग के विकार की "डिग्री"। विचार "अधिकतम एन्ट्रॉपी" की अवधारणा के संदर्भ में समझना सबसे आसान है।

अधिकतम एन्ट्रॉपी के साथ बिट्स की एक स्ट्रिंग की अनुमानित परिभाषा यह है कि इसे बिट्स की छोटी स्ट्रिंग के संदर्भ में बिल्कुल व्यक्त नहीं किया जा सकता है (यानी छोटे स्ट्रिंग को मूल स्ट्रिंग में वापस करने के लिए कुछ एल्गोरिदम का उपयोग करके)।

यादृच्छिकता के लिए अधिकतम एन्ट्रॉपी की प्रासंगिकता इस तथ्य से उत्पन्न होती है कि यदि आप "यादृच्छिक रूप से" संख्या चुनते हैं, तो आप लगभग निश्चित रूप से एक संख्या चुनेंगे जिसका बिट स्ट्रिंग अधिकतम एन्ट्रॉपी होने के करीब है, यानी इसे संपीड़ित नहीं किया जा सकता है। यह "यादृच्छिक" संख्या की विशेषता के बारे में हमारी सबसे अच्छी समझ है।

इसलिए, यदि आप यादृच्छिक रूप से "दो बार" दो यादृच्छिक नमूने से यादृच्छिक संख्या बनाना चाहते हैं, तो आप दो बिट स्ट्रिंग को एक साथ जोड़ देंगे। व्यावहारिक रूप से, आप केवल नमूने को डबल लम्बाई शब्द के उच्च और निम्न हिस्सों में रखेंगे।

एक और व्यावहारिक नोट पर, यदि आप खुद को एक क्रैपी रैंड () के साथ जोड़ते हैं, तो यह कभी-कभी कुछ नमूनों को एक साथ जोड़ने में मदद कर सकता है --- हालांकि, अगर यह वास्तव में टूटा हुआ भी है तो वह प्रक्रिया मदद नहीं करेगी।


जैसा कि अन्य ने कहा है, आसान संक्षिप्त उत्तर है: नहीं, यह अधिक यादृच्छिक नहीं है, लेकिन यह वितरण को बदलता है।

मान लीजिए कि आप एक पासा खेल खेल रहे थे। आपके पास कुछ पूरी तरह से निष्पक्ष, यादृच्छिक पासा है। क्या मरने के रोल "अधिक यादृच्छिक" होंगे यदि प्रत्येक मरने के रोल से पहले, आप पहले दो कटोरे को एक कटोरे में डालते हैं, इसे चारों ओर हिलाते हैं, पासा में से एक को यादृच्छिक रूप से उठाते हैं, और फिर उसे घुमाते हैं? स्पष्ट रूप से इससे कोई फर्क नहीं पड़ता। यदि दोनों पासा यादृच्छिक संख्या देते हैं, तो यादृच्छिक रूप से दो पासा में से किसी एक को चुनने से कोई फर्क नहीं पड़ता। किसी भी तरह से आपको पर्याप्त संख्या में रोल पर वितरण के साथ 1 और 6 के बीच यादृच्छिक संख्या मिल जाएगी।

मुझे लगता है कि वास्तविक जीवन में ऐसी प्रक्रिया उपयोगी हो सकती है यदि आपको संदेह है कि पासा उचित नहीं हो सकता है। यदि, कहते हैं, पासा थोड़ा असंतुलित होता है तो कोई व्यक्ति समय के 1/6 से अधिक बार देता है, और दूसरा 6 असामान्य रूप से अक्सर देता है, फिर बेतरतीब ढंग से दोनों के बीच चयन करना पूर्वाग्रह को अस्पष्ट करता है। (हालांकि इस मामले में, 1 और 6 अभी भी 2, 3, 4, और 5 से अधिक आते हैं। ठीक है, मुझे असंतुलन की प्रकृति के आधार पर लगता है।)

यादृच्छिकता की कई परिभाषाएं हैं। एक यादृच्छिक श्रृंखला की एक परिभाषा यह है कि यह एक यादृच्छिक प्रक्रिया द्वारा उत्पादित संख्याओं की एक श्रृंखला है। इस परिभाषा के अनुसार, यदि मैं निष्पक्ष मर जाता हूं तो 5 बार मर जाता है और संख्या 2, 4, 3, 2, 5 प्राप्त करता है, यह एक यादृच्छिक श्रृंखला है। यदि मैं फिर उसी मेले को 5 बार मर जाता हूं और 1, 1, 1, 1, 1 प्राप्त करता हूं, तो यह भी एक यादृच्छिक श्रृंखला है।

कई पोस्टर्स ने इंगित किया है कि कंप्यूटर पर यादृच्छिक कार्य वास्तव में यादृच्छिक नहीं बल्कि छद्म-यादृच्छिक हैं, और यदि आप एल्गोरिदम और बीज को जानते हैं तो वे पूरी तरह अनुमानित हैं। यह सच है, लेकिन ज्यादातर समय पूरी तरह से अप्रासंगिक है। अगर मैं कार्ड के डेक को घुमाता हूं और फिर उन्हें एक बार में बदल देता हूं, तो यह एक यादृच्छिक श्रृंखला होनी चाहिए। अगर कोई कार्ड पर देखता है, तो परिणाम पूरी तरह अनुमानित होगा, लेकिन यादृच्छिकता की अधिकांश परिभाषाओं से यह कम यादृच्छिक नहीं होगा। यदि श्रृंखला यादृच्छिकता के सांख्यिकीय परीक्षण पास करती है, तो तथ्य यह है कि मैंने कार्ड पर देखा है कि इस तथ्य को नहीं बदलेगा। व्यावहारिक रूप से, यदि हम अगले कार्ड का अनुमान लगाने की आपकी क्षमता पर बड़ी मात्रा में धन जुआ कर रहे हैं, तो तथ्य यह है कि आपने कार्ड पर देखा है वह बेहद प्रासंगिक है। यदि हम प्रणाली के प्रदर्शन की जांच करने के लिए हमारी वेबसाइट पर आगंतुकों की मेनू चुनौतियों का अनुकरण करने के लिए श्रृंखला का उपयोग कर रहे हैं, तो तथ्य यह है कि आपने देखा कि कोई फर्क नहीं पड़ता। (जब तक आप इस ज्ञान का लाभ उठाने के लिए प्रोग्राम को संशोधित नहीं करते हैं।)

संपादित करें

मुझे नहीं लगता कि मैं मॉन्टी हॉल की समस्या पर एक टिप्पणी में अपनी प्रतिक्रिया दे सकता हूं, इसलिए मैं अपना जवाब अपडेट करूंगा।

उन लोगों के लिए जिन्होंने बेलिसियस लिंक नहीं पढ़ा, इसका अर्थ यह है कि: एक गेम शो प्रतियोगी को 3 दरवाजे का विकल्प दिया जाता है। एक के पीछे एक मूल्यवान पुरस्कार है, दूसरों के पीछे कुछ बेकार है। वह दरवाजा # 1 उठाता है। यह खुलासा करने से पहले कि यह एक विजेता या हारने वाला है, मेजबान यह खुलासा करने के लिए दरवाजा # 3 खोलता है कि यह एक हारे हुए है। उसके बाद वह प्रतिभागी को दरवाजा # 2 पर स्विच करने का मौका देता है। क्या प्रतियोगी ऐसा कर सकता है या नहीं?

जवाब, जो कई लोगों के अंतर्ज्ञान को अपमानित करता है, वह है कि उसे स्विच करना चाहिए। संभावना है कि उसका मूल चयन विजेता था 1/3, दूसरा दरवाजा विजेता 2/3 है। मेरे शुरुआती अंतर्ज्ञान, कई अन्य लोगों के साथ, यह है कि स्विचिंग में कोई लाभ नहीं होगा, कि बाधाओं को अभी बदलकर 50:50 कर दिया गया है।

आखिरकार, मान लीजिए कि मेजबान खोने वाले दरवाजे को खोलने के बाद किसी ने टीवी पर स्विच किया था। उस व्यक्ति को दो शेष बंद दरवाजे दिखाई देंगे। मान लीजिए कि वह खेल की प्रकृति को जानता है, वह कहेंगे कि पुरस्कार छिपाने वाले प्रत्येक दरवाजे का 1/2 मौका है। दर्शक के लिए बाधाएं 1/2: 1/2 हो सकती हैं जबकि प्रतिभागी के लिए बाधाएं 1/3: 2/3 हैं?

मुझे अपने अंतर्ज्ञान को आकार में हरा करने के लिए वास्तव में इस बारे में सोचना पड़ा। इस पर एक संभाल पाने के लिए, समझें कि जब हम इस तरह की किसी समस्या में संभावनाओं के बारे में बात करते हैं, तो हमारा मतलब है, आपके द्वारा उपलब्ध कराई गई संभावना को उपलब्ध जानकारी दी गई है। चालक दल के एक सदस्य के लिए जो पुरस्कार पीछे रखता है, कहें, दरवाजा # 1, संभावना है कि पुरस्कार दरवाजा # 1 के पीछे है 100% है और संभावना है कि यह दो अन्य दरवाजे के पीछे है शून्य है।

चालक दल के सदस्य की बाधा प्रतिद्वंद्वी की बाधाओं से अलग होती है क्योंकि वह जानता है कि प्रतिभागी कुछ नहीं जानता, अर्थात्, किस दरवाजे पर उसने पुरस्कार दिया। Likewise, the contestent's odds are different than the viewer's odds because he knows something that the viewer doesn't, namely, which door he initially picked. This is not irrelevant, because the host's choice of which door to open is not random. He will not open the door the contestant picked, and he will not open the door that hides the prize. If these are the same door, that leaves him two choices. If they are different doors, that leaves only one.

So how do we come up with 1/3 and 2/3 ? When the contestant originally picked a door, he had a 1/3 chance of picking the winner. I think that much is obvious. That means there was a 2/3 chance that one of the other doors is the winner. If the host game him the opportunity to switch without giving any additional information, there would be no gain. Again, this should be obvious. But one way to look at it is to say that there is a 2/3 chance that he would win by switching. But he has 2 alternatives. So each one has only 2/3 divided by 2 = 1/3 chance of being the winner, which is no better than his original pick. Of course we already knew the final result, this just calculates it a different way.

But now the host reveals that one of those two choices is not the winner. So of the 2/3 chance that a door he didn't pick is the winner, he now knows that 1 of the 2 alternatives isn't it. The other might or might not be. So he no longer has 2/3 dividied by 2. He has zero for the open door and 2/3 for the closed door.


यह अधिक असतत संख्याओं में इसके बारे में सोचने में मदद कर सकता है। विचार करें कि 1 और 36 के बीच यादृच्छिक संख्याएं उत्पन्न करना चाहते हैं, इसलिए आप तय करते हैं कि दो मेले, 6-पक्षीय पासा फेंकने का सबसे आसान तरीका है। आपको यह मिलता है:

     1    2    3    4    5    6
  -----------------------------
1|   1    2    3    4    5    6
2|   2    4    6    8   10   12
3|   3    6    9   12   15   18
4|   4    8   12   16   20   24   
5|   5   10   15   20   25   30
6|   6   12   18   24   30   36

तो हमारे पास 36 संख्याएं हैं, लेकिन उनमें से सभी का प्रतिनिधित्व नहीं किया जाता है, और कुछ भी नहीं होते हैं। केंद्र विकर्ण (नीचे-बाएं कोने से ऊपर-दाएं कोने) के पास संख्या उच्च आवृत्ति के साथ घटित होगी।

पासा के बीच अनुचित वितरण का वर्णन करने वाले वही सिद्धांत 0.0 और 1.0 के बीच फ़्लोटिंग पॉइंट संख्याओं के बराबर लागू होते हैं।


यहां एक सरल जवाब है। एकाधिकार पर विचार करें। आप दो छः पक्षीय पासा (या उन लोगों के लिए 2 डी 6 रोल करते हैं जो गेमिंग नोटेशन पसंद करते हैं) और अपना योग लेते हैं। सबसे आम परिणाम 7 है क्योंकि 7 संभावित तरीके हैं जिन्हें आप 7 (1,6 2,5 3,4 4,3 5,2 और 6,1) रोल कर सकते हैं। जबकि एक 2 केवल 1,1 पर लुढ़का जा सकता है। यह देखना आसान है कि रोलिंग 2 डी 6 रोलिंग 1 डी 12 से अलग है, भले ही सीमा समान है (अनदेखा कि आप 1 डी 12 पर 1 प्राप्त कर सकते हैं, बिंदु वही रहता है)। उन्हें जोड़ने के बजाए अपने परिणामों को गुणा करने के लिए उन्हें एक ही फैशन में फेंकने जा रहा है, जिसमें आपके अधिकांश परिणाम सीमा के बीच में आते हैं। यदि आप आउटलाइजर्स को कम करने की कोशिश कर रहे हैं, तो यह एक अच्छी विधि है, लेकिन यह वितरण भी करने में मदद नहीं करेगा।

(और विचित्र रूप से पर्याप्त यह कम रोल भी बढ़ाएगा। मान लीजिए कि आपकी यादृच्छिकता 0 से शुरू होती है, आपको 0 पर एक स्पाइक दिखाई देगा क्योंकि यह जो भी अन्य रोल 0 में बदल जाएगा, 0 और 1 के बीच दो यादृच्छिक संख्याओं पर विचार करें (समावेशी ) और गुणा करना। अगर कोई परिणाम 0 है, तो पूरी चीज 0 न हो जाती है, इससे कोई फर्क नहीं पड़ता। इसके बाहर 1 प्राप्त करने का एकमात्र तरीका रोल दोनों के लिए है। अभ्यास में शायद इससे कोई फर्क नहीं पड़ता लेकिन यह एक अजीब ग्राफ के लिए बनाता है।)


स्वीकृत उत्तर काफी प्यारा है, लेकिन आपके प्रश्न का उत्तर देने का एक और तरीका है। पैचडर्मपंचर का जवाब पहले से ही इस वैकल्पिक दृष्टिकोण को लेता है, और मैं इसे थोड़ा विस्तारित करने जा रहा हूं।

सूचना सिद्धांत के बारे में सोचने का सबसे आसान तरीका जानकारी की सबसे छोटी इकाई, एक बिट के मामले में है।

सी मानक लाइब्रेरी में, rand() रेंज 0 में RAND_MAX में एक पूर्णांक देता है, एक सीमा जिसे प्लेटफ़ॉर्म के आधार पर अलग-अलग परिभाषित किया जा सकता है। मान लें कि RAND_MAX को 2^n - 1 रूप में परिभाषित किया जाना है जहां n कुछ पूर्णांक है (यह माइक्रोसॉफ्ट के कार्यान्वयन में मामला होता है, जहां n 15 है)। फिर हम कहेंगे कि एक अच्छा कार्यान्वयन जानकारी के n बिट्स वापस करेगा।

कल्पना कीजिए कि rand() एक बिट के मूल्य को खोजने के लिए एक सिक्का फिसलने के द्वारा यादृच्छिक संख्या बनाती है, और तब तक दोहराई जाती है जब तक कि इसमें 15 बिट्स का बैच न हो। फिर बिट्स स्वतंत्र होते हैं (किसी भी बिट का मूल्य उसी बैच में अन्य बिट्स की संभावना को प्रभावित नहीं करता है)। तो स्वतंत्र रूप से माना जाने वाला प्रत्येक बिट 0 और 1 समावेशी के बीच एक यादृच्छिक संख्या की तरह है, और उस सीमा पर "समान रूप से वितरित" है (जैसा कि 0 के रूप में 0 होने की संभावना है)।

बिट्स की स्वतंत्रता सुनिश्चित करता है कि बिट्स के बैचों द्वारा प्रतिनिधित्व की गई संख्या को भी उनकी सीमा पर समान रूप से वितरित किया जाएगा। यह सहजता से स्पष्ट है: यदि 15 बिट्स हैं, तो अनुमत सीमा शून्य से 2^15 - 1 = 32767 है। उस सीमा में प्रत्येक संख्या बिट्स का एक अद्वितीय पैटर्न है, जैसे कि:

010110101110010

और यदि बिट स्वतंत्र हैं तो किसी भी पैटर्न से किसी भी पैटर्न की तुलना में अधिक होने की संभावना नहीं है। तो सीमा में सभी संभावित संख्या समान रूप से संभावना है। और इसलिए रिवर्स सत्य है: यदि rand() समान रूप से वितरित पूर्णांक उत्पन्न करता है, तो उन संख्याओं को स्वतंत्र बिट्स से बना दिया जाता है।

तो rand() को बिट्स बनाने के लिए उत्पादन लाइन के रूप में सोचें, जो मनमाने ढंग से आकार के बैचों में उनकी सेवा करने के लिए होता है। यदि आपको आकार पसंद नहीं है, तो अलग-अलग बिट्स में बैचों को तोड़ दें, और फिर उन्हें अपनी पसंद की मात्रा में एक साथ वापस रखें (हालांकि यदि आपको किसी विशेष श्रेणी की आवश्यकता है जो 2 की शक्ति नहीं है, तो आपको अपनी संख्याओं को कम करने की आवश्यकता है , और ऐसा करने का सबसे आसान तरीका फ़्लोटिंग पॉइंट में कनवर्ट करना है)।

अपने मूल सुझाव पर लौटते हुए, मान लीजिए कि आप 15 के बैच से 30 तक बैचों से जाना चाहते हैं, पहले नंबर के लिए rand() पूछें, इसे 15 स्थानों पर थोड़ा-सा स्थानांतरित करें, फिर इसमें एक और rand() जोड़ें। एक वितरण को परेशान किए बिना दो कॉल को rand() जोड़ना एक तरीका है। यह केवल इसलिए काम करता है क्योंकि उन स्थानों के बीच कोई ओवरलैप नहीं है जहां आप जानकारी के बिट्स डालते हैं।

निरंतर द्वारा गुणा करके rand() की सीमा को "खींचने" के लिए यह बहुत अलग है। उदाहरण के लिए, यदि आप rand() की श्रेणी को दोगुना करना चाहते हैं तो आप दो से गुणा कर सकते हैं - लेकिन अब आप केवल संख्याएं भी प्राप्त करेंगे, और कभी भी विषम संख्याएं नहीं! यह वास्तव में एक चिकनी वितरण नहीं है और एप्लिकेशन के आधार पर एक गंभीर समस्या हो सकती है, उदाहरण के लिए एक रूले-जैसा गेम माना जाता है कि अजीब / यहां तक ​​कि दांव भी लगाए जाते हैं। (बिट्स के मामले में सोचकर, आप उस गलती से सहजता से बचेंगे, क्योंकि आप महसूस करेंगे कि दो से गुणा करना एक ही स्थान पर बाइट्स (अधिक महत्व) को स्थानांतरित करना और शून्य के साथ अंतर को भरना जैसा ही है। तो जाहिर है कि जानकारी की मात्रा एक जैसी है - यह बस थोड़ा सा स्थानांतरित हो गया।)

संख्या श्रेणियों में इस तरह के अंतराल को फ्लोटिंग पॉइंट नंबर अनुप्रयोगों में नहीं पकड़ा जा सकता है, क्योंकि फ्लोटिंग पॉइंट में अंतर्निहित रूप से अंतराल होता है, जिसे आसानी से प्रदर्शित नहीं किया जा सकता है: प्रत्येक दो प्रतिनिधित्व करने योग्य फ़्लोटिंग के बीच अंतर में असीमित वास्तविक संख्या मौजूद है बिंदु संख्या! तो हमें वैसे भी अंतराल के साथ जीना सीखना है।

जैसा कि अन्य ने चेतावनी दी है, अंतर्ज्ञान इस क्षेत्र में जोखिम भरा है, खासतौर पर क्योंकि गणितज्ञ वास्तविक संख्याओं के आकर्षण का विरोध नहीं कर सकते हैं, जो बहुत ही भ्रमित चीजें हैं जो बदसूरत infinities और स्पष्ट विरोधाभास से भरा है।

लेकिन कम से कम अगर आपको लगता है कि बिट्स की शर्तें हैं, तो आपकी अंतर्ज्ञान आपको थोड़ी और आगे ले सकती है। बिट्स वास्तव में आसान हैं - यहां तक ​​कि कंप्यूटर भी उन्हें समझ सकते हैं।


एक बिंदु को चित्रित करने के लिए Oversimplification।

मान लें कि आपका यादृच्छिक फ़ंक्शन केवल 0 या 1 आउटपुट करता है।

random() (0,1) random() से एक है, लेकिन random()*random() से एक है (0,0,0,1)

आप स्पष्ट रूप से देख सकते हैं कि दूसरे मामले में 0 प्राप्त करने की संभावना 1 पाने के लिए समान नहीं है।

जब मैंने पहली बार यह उत्तर पोस्ट किया था तो मैं इसे जितना संभव हो सके छोटा रखना चाहता था ताकि एक व्यक्ति इसे पढ़ने के लिए random() और random()*random() बीच अंतर को समझ सके, लेकिन मैं खुद को जवाब देने से नहीं रोक सकता मूल विज्ञापन लिटरम सवाल:

कौन सा यादृच्छिक है?

random() , random()*random() , random()+random() , (random()+1)/2 या कोई अन्य संयोजन जो एक निश्चित परिणाम का कारण नहीं बनता है, एंट्रॉपी का एक ही स्रोत होता है (या छद्म यादृच्छिक जेनरेटर के मामले में एक ही प्रारंभिक स्थिति), जवाब यह होगा कि वे समान रूप से यादृच्छिक हैं (अंतर उनके वितरण में है)। एक आदर्श उदाहरण जिसे हम देख सकते हैं वह क्रेप्स का खेल है। आपको जो संख्या मिलती है वह random(1,6)+random(1,6) और हम सभी जानते हैं कि 7 प्राप्त करने का उच्चतम मौका है, लेकिन इसका मतलब यह नहीं है कि दो पासा रोलिंग का परिणाम कम या ज्यादा यादृच्छिक है रोलिंग का परिणाम।


As others already pointed out, this question is hard to answer since everyone of us has his own picture of randomness in his head.

That is why, I would highly recommend you to take some time and read through this site to get a better idea of randomness:

To get back to the real question. There is no more or less random in this term:

both only appears random !

In both cases - just rand() or rand() * rand() - the situation is the same: After a few billion of numbers the sequence will repeat(!) . It appears random to the observer, because he does not know the whole sequence, but the computer has no true random source - so he can not produce randomness either.

eg: Is the weather random? We do not have enough sensors or knowledge to determine if weather is random or not.


Consider you have a simple coin flip problem where even is considered heads and odd is considered tails. The logical implementation is:

rand() mod 2

Over a large enough distribution, the number of even numbers should equal the number of odd numbers.

Now consider a slight tweak:

rand() * rand() mod 2

If one of the results is even, then the entire result should be even. Consider the 4 possible outcomes (even * even = even, even * odd = even, odd * even = even, odd * odd = odd). Now, over a large enough distribution, the answer should be even 75% of the time.

I'd bet heads if I were you.

This comment is really more of an explanation of why you shouldn't implement a custom random function based on your method than a discussion on the mathematical properties of randomness.


It's easy to show that the sum of the two random numbers is not necessarily random. Imagine you have a 6 sided die and roll. Each number has a 1/6 chance of appearing. Now say you had 2 dice and summed the result. The distribution of those sums is not 1/12. क्यूं कर? Because certain numbers appear more than others. There are multiple partitions of them. For example the number 2 is the sum of 1+1 only but 7 can be formed by 3+4 or 4+3 or 5+2 etc... so it has a larger chance of coming up.

Therefore, applying a transform, in this case addition on a random function does not make it more random, or necessarily preserve randomness. In the case of the dice above, the distribution is skewed to 7 and therefore less random.


It's not exactly obvious, but rand() is typically more random than rand()*rand() . What's important is that this isn't actually very important for most uses.

But firstly, they produce different distributions. This is not a problem if that is what you want, but it does matter. If you need a particular distribution, then ignore the whole “which is more random” question. So why is rand() more random?

The core of why rand() is more random (under the assumption that it is producing floating-point random numbers with the range [0..1], which is very common) is that when you multiply two FP numbers together with lots of information in the mantissa, you get some loss of information off the end; there's just not enough bit in an IEEE double-precision float to hold all the information that was in two IEEE double-precision floats uniformly randomly selected from [0..1], and those extra bits of information are lost. Of course, it doesn't matter that much since you (probably) weren't going to use that information, but the loss is real. It also doesn't really matter which distribution you produce (ie, which operation you use to do the combination). Each of those random numbers has (at best) 52 bits of random information – that's how much an IEEE double can hold – and if you combine two or more into one, you're still limited to having at most 52 bits of random information.

Most uses of random numbers don't use even close to as much randomness as is actually available in the random source. Get a good PRNG and don't worry too much about it. (The level of “goodness” depends on what you're doing with it; you have to be careful when doing Monte Carlo simulation or cryptography, but otherwise you can probably use the standard PRNG as that's usually much quicker.)


Multiplying numbers would end up in a smaller solution range depending on your computer architecture.

If the display of your computer shows 16 digits rand() would be say 0.1234567890123 multiplied by a second rand() , 0.1234567890123, would give 0.0152415 something you'd definitely find fewer solutions if you'd repeat the experiment 10^14 times.


OK, so I will try to add some value to complement others answers by saying that you are creating and using a random number generator.

Random number generators are devices (in a very general sense) that have multiple characteristics which can be modified to fit a purpose. Some of them (from me) are:

  • Entropy: as in Shannon Entropy
  • Distribution: statistical distribution (poisson, normal, etc.)
  • Type: what is the source of the numbers (algorithm, natural event, combination of, etc.) and algorithm applied.
  • Efficiency: rapidity or complexity of execution.
  • Patterns: periodicity, sequences, runs, etc.
  • and probably more...

In most answers here, distribution is the main point of interest, but by mix and matching functions and parameters, you create new ways of generating random numbers which will have different characteristics for some of which the evaluation may not be obvious at first glance.


Use a linear feedback shift register (LFSR) that implements a primitive polynomial.

The result will be a sequence of 2^n pseudo-random numbers, ie none repeating in the sequence where n is the number of bits in the LFSR .... resulting in a uniform distribution.

http://en.wikipedia.org/wiki/Linear_feedback_shift_register http://www.xilinx.com/support/documentation/application_notes/xapp052.pdf

Use a "random" seed based on microsecs of your computer clock or maybe a subset of the md5 result on some continuously changing data in your file system.

For example, a 32-bit LFSR will generate 2^32 unique numbers in sequence (no 2 alike) starting with a given seed. The sequence will always be in the same order, but the starting point will be different (obviously) for a different seeds. So, if a possibly repeating sequence between seedings is not a problem, this might be a good choice.

I've used 128-bit LFSR's to generate random tests in hardware simulators using a seed which is the md5 results on continuously changing system data.


We can compare two arrays of numbers regarding the randomness by using Kolmogorov complexity If the sequence of numbers can not be compressed, then it is the most random we can reach at this length... I know that this type of measurement is more a theoretical option...








random