मैंने ऊपर दिए गए लगभग 40 अन्य पृष्ठों को इस तरह से c ++ के साथ लाल कर दिया और Stephan T. Lavavej "STL" से वीडियो देखा
और फिर भी यह निश्चित नहीं था कि प्रैक्सी में यादृच्छिक संख्या कैसे काम करती है इसलिए मुझे पता लगाने के लिए एक पूरा रविवार लगा। इसके बारे में क्या और कैसे काम करता है और इसका इस्तेमाल किया जा सकता है।
मेरी राय में एसटीएल "सरंड का उपयोग नहीं करना" के बारे में सही है और उसने वीडियो 2 में इसे अच्छी तरह से समझाया । वह भी उपयोग करने की सलाह देते हैं:
a) void random_device_uniform()- एन्क्रिप्टेड जेनरेशन के लिए लेकिन धीमा (मेरे उदाहरण से)
बी) के साथ उदाहरण mt19937- तेज, बीज बनाने की क्षमता, एन्क्रिप्टेड नहीं
मैंने सभी दावा किए गए c ++ 11 पुस्तकों को बाहर निकाला है जिनकी मुझे एक्सेस है और पाया कि ब्रिमन (2015) जैसे जर्मन लेखक अभी भी इसके एक समूह का उपयोग करते हैं
srand( time( 0 ) );
srand( static_cast<unsigned int>(time(nullptr))); or
srand( static_cast<unsigned int>(time(NULL))); or
सिर्फ #includings के <random>बजाय <time> and <cstdlib>- तो बस एक किताब से सीखने के लिए सावधान रहें :)।
अर्थ - जिसका उपयोग c ++ 11 से नहीं किया जाना चाहिए क्योंकि:
कार्यक्रमों को अक्सर यादृच्छिक संख्याओं के स्रोत की आवश्यकता होती है। नए मानक से पहले, C और C ++ दोनों रैंड नामक एक साधारण सी लाइब्रेरी फ़ंक्शन पर निर्भर थे। यह फ़ंक्शन pseudorandom integers पैदा करता है जो समान रूप से 0 से एक सिस्टम तक निर्भर में वितरित किए जाते हैं- अधिकतम निर्भरता जो कि कम से कम 32767 है। रैंड फ़ंक्शन में कई समस्याएं हैं: कई, यदि अधिकांश नहीं, तो प्रोग्रामों को एक अलग श्रेणी में यादृच्छिक संख्याओं की आवश्यकता होती है एक रैंड द्वारा उत्पादित। कुछ अनुप्रयोगों के लिए रैंडम फ्लोटिंग-पॉइंट नंबरों की आवश्यकता होती है। कुछ कार्यक्रमों को संख्या की आवश्यकता होती है जो एक गैर-समान वितरण को दर्शाते हैं। प्रोग्रामर अक्सर गैर-आयामीता का परिचय देते हैं जब वे रैंड द्वारा उत्पन्न संख्याओं की सीमा, प्रकार, या वितरण को बदलने की कोशिश करते हैं। (लीपमैन सी ++ प्राइमर पांचवें संस्करण 2012 का उद्धरण)
मुझे अंततः बेज़र्न स्ट्रॉन्स्टअप्स में 20 पुस्तकों में से एक सबसे अच्छा स्पष्टीकरण मिला - और उसे अपना सामान जानना चाहिए - "C ++ 2019 का एक दौरा", "प्रोग्रामिंग सिद्धांतों और अभ्यास का उपयोग C ++ 2016" और "C ++ प्रोग्रामिंग लैंग्वेज 4th संस्करण"। 2014 "और" लिप्समैन सी ++ प्राइमर पांचवें संस्करण 2012 "में भी कुछ उदाहरण:
और यह वास्तव में सरल है क्योंकि एक यादृच्छिक संख्या जनरेटर में दो भाग होते हैं:
(1) एक इंजन जो यादृच्छिक या छद्म यादृच्छिक मूल्यों के अनुक्रम का उत्पादन करता है। (2) एक वितरण जो उन मानों को एक श्रेणी में गणितीय वितरण में मैप करता है।
Microsofts STL आदमी की राय के बावजूद, Bjarne Stroustrups लिखते हैं:
में, मानक पुस्तकालय यादृच्छिक संख्या इंजन और वितरण ()24.7) प्रदान करता है। डिफ़ॉल्ट रूप से default_random_engine का उपयोग करें, जिसे व्यापक प्रयोज्यता और कम लागत के लिए चुना जाता है।
इसका void die_roll()उदाहरण ब्रेज़न स्ट्रॉस्ट्रुप्स से है - अच्छा विचार पैदा करने वाला इंजन और इसके साथ वितरण using (अधिक मुक्केबाज़ी) ।
मानक पुस्तकालय द्वारा प्रदान किए गए यादृच्छिक संख्या जनरेटर का व्यावहारिक उपयोग करने में सक्षम होने के लिए <random> यहां कुछ अलग-अलग उदाहरणों के साथ कुछ निष्पादन योग्य कोड कम से कम आवश्यक हैं जो उम्मीद करते हैं कि आप लोगों के लिए सुरक्षित समय और धन:
#include <random> //random engine, random distribution
#include <iostream> //cout
#include <functional> //to use bind
using namespace std;
void space() //for visibility reasons if you execute the stuff
{
cout << "\n" << endl;
for (int i = 0; i < 20; ++i)
cout << "###";
cout << "\n" << endl;
}
void uniform_default()
{
// uniformly distributed from 0 to 6 inclusive
uniform_int_distribution<size_t> u (0, 6);
default_random_engine e; // generates unsigned random integers
for (size_t i = 0; i < 10; ++i)
// u uses e as a source of numbers
// each call returns a uniformly distributed value in the specified range
cout << u(e) << " ";
}
void random_device_uniform()
{
space();
cout << "random device & uniform_int_distribution" << endl;
random_device engn;
uniform_int_distribution<size_t> dist(1, 6);
for (int i=0; i<10; ++i)
cout << dist(engn) << ' ';
}
void die_roll()
{
space();
cout << "default_random_engine and Uniform_int_distribution" << endl;
using my_engine = default_random_engine;
using my_distribution = uniform_int_distribution<size_t>;
my_engine rd {};
my_distribution one_to_six {1, 6};
auto die = bind(one_to_six,rd); // the default engine for (int i = 0; i<10; ++i)
for (int i = 0; i <10; ++i)
cout << die() << ' ';
}
void uniform_default_int()
{
space();
cout << "uniform default int" << endl;
default_random_engine engn;
uniform_int_distribution<size_t> dist(1, 6);
for (int i = 0; i<10; ++i)
cout << dist(engn) << ' ';
}
void mersenne_twister_engine_seed()
{
space();
cout << "mersenne twister engine with seed 1234" << endl;
//mt19937 dist (1234); //for 32 bit systems
mt19937_64 dist (1234); //for 64 bit systems
for (int i = 0; i<10; ++i)
cout << dist() << ' ';
}
void random_seed_mt19937_2()
{
space();
cout << "mersenne twister split up in two with seed 1234" << endl;
mt19937 dist(1234);
mt19937 engn(dist);
for (int i = 0; i < 10; ++i)
cout << dist() << ' ';
cout << endl;
for (int j = 0; j < 10; ++j)
cout << engn() << ' ';
}
int main()
{
uniform_default();
random_device_uniform();
die_roll();
random_device_uniform();
mersenne_twister_engine_seed();
random_seed_mt19937_2();
return 0;
}
मुझे लगता है कि यह सभी को जोड़ता है और जैसा मैंने कहा, यह मुझे उस उदाहरणों को नष्ट करने के लिए पढ़ने और समय का एक गुच्छा ले गया - यदि आपके पास संख्या पीढ़ी के बारे में और अधिक सामान है, तो मैं उस बारे में सुनकर खुश हूं जो कि दोपहर या टिप्पणी अनुभाग में है। और यदि आवश्यक हो या इस पोस्ट को संपादित करेंगे। बूल