🥇BlessRNG या ईमानदारी के लिए RNG की जाँच करना

खेल के विकास में, आपको अक्सर यादृच्छिकता के साथ कुछ जोड़ने की आवश्यकता होती है: इसके लिए यूनिटी का अपना रैंडम होता है, और इसके समानांतर System.Random होता है। एक बार, एक परियोजना पर, मुझे यह आभास हुआ कि दोनों अलग-अलग तरीके से काम कर सकते हैं (हालाँकि उनका वितरण भी समान होना चाहिए)।

तब वे विवरण में नहीं गए - यह पर्याप्त था कि System.Random में परिवर्तन ने सभी समस्याओं को ठीक कर दिया। अब हमने इस पर अधिक विस्तार से गौर करने और थोड़ा शोध करने का निर्णय लिया: कैसे "पक्षपातपूर्ण" या पूर्वानुमानित आरएनजी हैं, और किसे चुनना है। इसके अलावा, मैंने उनकी "ईमानदारी" के बारे में एक से अधिक बार परस्पर विरोधी राय सुनी है - आइए यह पता लगाने की कोशिश करें कि वास्तविक परिणामों की तुलना घोषित परिणामों से कैसे की जाती है।

संक्षिप्त शैक्षिक कार्यक्रम या आरएनजी वास्तव में आरएनजी है

यदि आप पहले से ही यादृच्छिक संख्या जनरेटर से परिचित हैं, तो आप तुरंत "परीक्षण" अनुभाग पर जा सकते हैं।

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

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

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

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

पीआरएनजी बनाने के लिए कई विकल्प हैं, लेकिन निम्नलिखित सभी के लिए प्रासंगिक होगा:

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

आपको पीआरएनजी की विशेषता बताने वाले संभाव्यता वितरण को भी जानना होगा - यह कौन सी संख्याएं उत्पन्न करेगा और किस संभाव्यता के साथ। अक्सर यह या तो सामान्य वितरण होता है या समान वितरण होता है।

सामान्य वितरण (बाएं) और समान वितरण (दाएं)

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

यदि आप इनमें से 10 पासे एक साथ फेंकें और कुल अंक गिनें तो क्या होगा? क्या इसके लिए एकरूपता कायम रखी जायेगी? नहीं। अक्सर, राशि 125 अंक के करीब होगी, यानी कुछ औसत मूल्य तक। और परिणामस्वरूप, थ्रो करने से पहले ही, आप भविष्य के परिणाम का मोटे तौर पर अनुमान लगा सकते हैं।

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

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

सहमत हूं कि बाईं ओर का विकल्प वास्तविक जीवन के करीब है - यह सामान्य वितरण वाला आरएनजी है। लेकिन यदि आपको अंधेरे आकाश में तारे बिखेरने की आवश्यकता है, तो समान वितरण के साथ आरएनजी का उपयोग करके प्राप्त किया गया सही विकल्प बेहतर अनुकूल है। सामान्य तौर पर, हाथ में लिए गए कार्य के आधार पर जनरेटर चुनें।

अब बात करते हैं पीएनजी अनुक्रम की एन्ट्रापी के बारे में। उदाहरण के लिए, एक क्रम है जो इस प्रकार शुरू होता है:

89, 93, 33, 32, 82, 21, 4, 42, 11, 8, 60, 95, 53, 30, 42, 19, 34, 35, 62, 23, 44, 38, 74, 36, 52, 18, 58, 79, 65, 45, 99, 90, 82, 20, 41, 13, 88, 76, 82, 24, 5, 54, 72, 19, 80, 2, 74, 36, 71, 9, ...

पहली नज़र में ये संख्याएँ कितनी यादृच्छिक हैं? आइए वितरण की जाँच करके शुरुआत करें।

यह एकरूपता के करीब दिखता है, लेकिन यदि आप दो संख्याओं के अनुक्रम को पढ़ते हैं और उन्हें एक विमान पर निर्देशांक के रूप में व्याख्या करते हैं, तो आपको यह मिलता है:

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

एक और क्रम:

42, 72, 17, 0, 30, 0, 15, 9, 47, 19, 35, 86, 40, 54, 97, 42, 69, 19, 20, 88, 4, 3, 67, 27, 42, 56, 17, 14, 20, 40, 80, 97, 1, 31, 69, 13, 88, 89, 76, 9, 4, 85, 17, 88, 70, 10, 42, 98, 96, 53, ...

यहाँ हवाई जहाज़ पर भी सब कुछ ठीक लग रहा है:

आइए वॉल्यूम में देखें (एक समय में तीन संख्याएं पढ़ें):

और फिर से पैटर्न. अब चार आयामों में विज़ुअलाइज़ेशन बनाना संभव नहीं है। लेकिन पैटर्न इस आयाम पर और बड़े आयामों पर मौजूद हो सकते हैं।

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

परीक्षण

यदि हम किसी चीज़ को निश्चित रूप से नहीं जानते हैं, तो उसके साथ कैसे काम करें? यदि आप नहीं जानते कि कौन सी ट्रैफिक लाइट इसकी अनुमति देती है तो क्या सड़क पार करना उचित है? परिणाम भिन्न हो सकते हैं.

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

और यदि आप नहीं जानते कि उपकरण कैसे काम करता है, तो आप इसका सही ढंग से उपयोग नहीं कर पाएंगे। सामान्य तौर पर, कम से कम वितरण के बारे में अंततः सुनिश्चित करने के लिए जांच करने और एक प्रयोग करने का समय आ गया है।

समाधान सरल और प्रभावी था - आँकड़े एकत्र करें, वस्तुनिष्ठ डेटा प्राप्त करें और परिणामों को देखें।

अध्ययन का विषय

यूनिटी में यादृच्छिक संख्याएँ उत्पन्न करने के कई तरीके हैं - हमने पाँच का परीक्षण किया।

सिस्टम.रैंडम.नेक्स्ट(). मानों की दी गई श्रेणी में पूर्णांक उत्पन्न करता है।
सिस्टम.रैंडम.नेक्स्टडबल()। [0; से सीमा में दोहरी परिशुद्धता संख्याएँ उत्पन्न करता है; 1).
UnityEngine.Random.Range(). मानों की दी गई श्रेणी में एकल सटीक संख्याएं (फ़्लोट्स) उत्पन्न करता है।
UnityEngine.Random.value. [0 से सीमा में एकल परिशुद्धता संख्याएं (फ्लोट्स) उत्पन्न करता है; 1).
Unity.Mathematics.Random.NextFloat(). नई Unity.Mathematics लाइब्रेरी का हिस्सा। मानों की दी गई श्रेणी में एकल सटीक संख्याएं (फ़्लोट्स) उत्पन्न करता है।

दस्तावेज़ीकरण में लगभग हर जगह एक समान वितरण निर्दिष्ट किया गया था, UnityEngine.Random.value के अपवाद के साथ (जहां वितरण निर्दिष्ट नहीं किया गया था, लेकिन UnityEngine.Random.Range() के अनुरूप वर्दी की भी उम्मीद थी) और Unity.Mathematics.Random .NextFloat() (जहां आधार xorshift एल्गोरिथ्म है, जिसका अर्थ है कि फिर से आपको एक समान वितरण के लिए प्रतीक्षा करने की आवश्यकता है)।

डिफ़ॉल्ट रूप से, अपेक्षित परिणाम दस्तावेज़ में निर्दिष्ट परिणामों के अनुसार लिए गए थे।

तकनीक

हमने एक छोटा एप्लिकेशन लिखा, जिसने प्रस्तुत तरीकों में से प्रत्येक का उपयोग करके यादृच्छिक संख्याओं के अनुक्रम तैयार किए और परिणामों को आगे की प्रक्रिया के लिए सहेजा।

प्रत्येक अनुक्रम की लंबाई 100 संख्या है।
यादृच्छिक संख्याओं का परिसर [0, 100) है।

डेटा कई लक्ष्य प्लेटफार्मों से एकत्र किया गया था:

Windows
- यूनिटी v2018.3.14f1, संपादक मोड, मोनो, .NET मानक 2.0
macOS
- यूनिटी v2018.3.14f1, संपादक मोड, मोनो, .NET मानक 2.0
- यूनिटी v5.6.4p4, संपादक मोड, मोनो, .NET मानक 2.0
Android
- यूनिटी v2018.3.14f1, प्रति डिवाइस बिल्ड, मोनो, .NET मानक 2.0
iOS
- यूनिटी v2018.3.14f1, बिल्ड प्रति डिवाइस, il2cpp, .NET मानक 2.0

कार्यान्वयन

हमारे पास यादृच्छिक संख्याएँ उत्पन्न करने के कई अलग-अलग तरीके हैं। उनमें से प्रत्येक के लिए, हम एक अलग रैपर वर्ग लिखेंगे, जो प्रदान करना चाहिए:

मानों की सीमा निर्धारित करने की संभावना [न्यूनतम/अधिकतम)। कंस्ट्रक्टर के माध्यम से सेट किया जाएगा.
एमएफ लौटाने की विधि. आइए प्रकार के रूप में फ़्लोट चुनें, क्योंकि यह अधिक सामान्य है।
परिणामों को चिह्नित करने के लिए जनरेशन विधि का नाम. सुविधा के लिए, हम मान के रूप में वर्ग का पूरा नाम + एमएफ उत्पन्न करने के लिए उपयोग की जाने वाली विधि का नाम लौटाएंगे।

सबसे पहले, आइए एक अमूर्त घोषित करें जिसे IRandomGenerator इंटरफ़ेस द्वारा दर्शाया जाएगा:

namespace RandomDistribution
{
    public interface IRandomGenerator
    {
        string Name { get; }

        float Generate();
    }
}

System.Random.Next() का कार्यान्वयन

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

using System;

namespace RandomDistribution
{
    public class SystemIntegerRandomGenerator : IRandomGenerator
    {
        private const int DefaultFactor = 100000;
        
        private readonly Random _generator = new Random();
        private readonly int _min;
        private readonly int _max;
        private readonly int _factor;


        public string Name => "System.Random.Next()";


        public SystemIntegerRandomGenerator(float min, float max, int factor = DefaultFactor)
        {
            _min = (int)min * factor;
            _max = (int)max * factor;
            _factor = factor;
        }


        public float Generate() => (float)_generator.Next(_min, _max) / _factor;
    }
}

System.Random.NextDouble() का कार्यान्वयन

यहां मानों की निश्चित सीमा [0; 1). इसे कंस्ट्रक्टर में निर्दिष्ट एक पर प्रोजेक्ट करने के लिए, हम सरल अंकगणित का उपयोग करते हैं: एक्स * (अधिकतम - न्यूनतम) + मिनट।

using System;

namespace RandomDistribution
{
    public class SystemDoubleRandomGenerator : IRandomGenerator
    {
        private readonly Random _generator = new Random();
        private readonly double _factor;
        private readonly float _min;


        public string Name => "System.Random.NextDouble()";


        public SystemDoubleRandomGenerator(float min, float max)
        {
            _factor = max - min;
            _min = min;
        }


        public float Generate() => (float)(_generator.NextDouble() * _factor) + _min;
    }
}

UnityEngine.Random.Range() का कार्यान्वयन

UnityEngine.Random स्थैतिक वर्ग की यह विधि आपको मानों की एक श्रृंखला निर्धारित करने और एक फ्लोट प्रकार लौटाने की अनुमति देती है। आपको कोई अतिरिक्त परिवर्तन करने की आवश्यकता नहीं है.

using UnityEngine;

namespace RandomDistribution
{
    public class UnityRandomRangeGenerator : IRandomGenerator
    {
        private readonly float _min;
        private readonly float _max;


        public string Name => "UnityEngine.Random.Range()";


        public UnityRandomRangeGenerator(float min, float max)
        {
            _min = min;
            _max = max;
        }


        public float Generate() => Random.Range(_min, _max);
    }
}

UnityEngine.Random.value का कार्यान्वयन

स्थिर वर्ग UnityEngine.Random की मान संपत्ति मानों की एक निश्चित सीमा से एक फ्लोट प्रकार लौटाती है [0; 1). आइए इसे किसी दिए गए रेंज पर उसी तरह प्रोजेक्ट करें जैसे System.Random.NextDouble() को लागू करते समय।

using UnityEngine;

namespace RandomDistribution
{
    public class UnityRandomValueGenerator : IRandomGenerator
    {
        private readonly float _factor;
        private readonly float _min;


        public string Name => "UnityEngine.Random.value";


        public UnityRandomValueGenerator(float min, float max)
        {
            _factor = max - min;
            _min = min;
        }


        public float Generate() => (float)(Random.value * _factor) + _min;
    }
}

Unity.Mathematics.Random.NextFloat() का कार्यान्वयन

Unity.Mathematics.Random क्लास की NextFloat() विधि फ्लोट प्रकार का एक फ़्लोटिंग पॉइंट लौटाती है और आपको मानों की एक श्रृंखला निर्दिष्ट करने की अनुमति देती है। एकमात्र बारीकियां यह है कि Unity.Mathematics.Random के प्रत्येक उदाहरण को कुछ बीज के साथ प्रारंभ करना होगा - इस तरह हम दोहराए जाने वाले अनुक्रम उत्पन्न करने से बचेंगे।

using Unity.Mathematics;

namespace RandomDistribution
{
    public class UnityMathematicsRandomValueGenerator : IRandomGenerator
    {
        private Random _generator;
        private readonly float _min;
        private readonly float _max;


        public string Name => "Unity.Mathematics.Random.NextFloat()";


        public UnityMathematicsRandomValueGenerator(float min, float max)
        {
            _min = min;
            _max = max;
            _generator = new Random();
            _generator.InitState(unchecked((uint)System.DateTime.Now.Ticks));
        }


        public float Generate() => _generator.NextFloat(_min, _max);
    }
}

मेनकंट्रोलर का कार्यान्वयन

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

आइए डेटासेट का आकार और एमएफ मानों की सीमा निर्धारित करें, और एक विधि भी प्राप्त करें जो कॉन्फ़िगर किए गए और काम करने के लिए तैयार जेनरेटर की एक सरणी लौटाती है।

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        private const int DefaultDatasetSize = 100000;

        public float MinValue = 0f;
        public float MaxValue = 100f;

        ...

        private IRandomGenerator[] CreateRandomGenerators()
        {
            return new IRandomGenerator[]
            {
                new SystemIntegerRandomGenerator(MinValue, MaxValue),
                new SystemDoubleRandomGenerator(MinValue, MaxValue),
                new UnityRandomRangeGenerator(MinValue, MaxValue),
                new UnityRandomValueGenerator(MinValue, MaxValue),
                new UnityMathematicsRandomValueGenerator(MinValue, MaxValue)
            };
        }

        ...
    }
}

अब एक डेटासेट बनाते हैं। इस मामले में, डेटा जेनरेशन को परिणामों को टेक्स्ट स्ट्रीम (सीएसवी प्रारूप में) में रिकॉर्ड करने के साथ जोड़ा जाएगा। प्रत्येक IRandomGenerator के मानों को संग्रहीत करने के लिए, उसका अपना अलग कॉलम आवंटित किया जाता है, और पहली पंक्ति में जनरेटर का नाम होता है।

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        ...
		
        private void GenerateCsvDataSet(TextWriter writer, int dataSetSize, params IRandomGenerator[] generators)
        {
            const char separator = ',';
            int lastIdx = generators.Length - 1;

            // write header
            for (int j = 0; j <= lastIdx; j++)
            {
                writer.Write(generators[j].Name);
                if (j != lastIdx)
                    writer.Write(separator);
            }
            writer.WriteLine();

            // write data
            for (int i = 0; i <= dataSetSize; i++)
            {
                for (int j = 0; j <= lastIdx; j++)
                {
                    writer.Write(generators[j].Generate());
                    if (j != lastIdx)
                        writer.Write(separator);
                }

                if (i != dataSetSize)
                    writer.WriteLine();
            }
        }

        ...
    }
}

जो कुछ बचा है वह है GenerateCsvDataSet विधि को कॉल करना और परिणाम को एक फ़ाइल में सहेजना, या तुरंत नेटवर्क पर डेटा को अंतिम डिवाइस से प्राप्तकर्ता सर्वर पर स्थानांतरित करना है।

namespace RandomDistribution
{
    public class MainController : MonoBehaviour
    {
        ...
		
        public void GenerateCsvDataSet(string path, int dataSetSize, params IRandomGenerator[] generators)
        {
            using (var writer = File.CreateText(path))
            {
                GenerateCsvDataSet(writer, dataSetSize, generators);
            }
        }


        public string GenerateCsvDataSet(int dataSetSize, params IRandomGenerator[] generators)
        {
            using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
            {
                GenerateCsvDataSet(writer, dataSetSize, generators);
                return writer.ToString();
            }
        }

        ...
    }
}

परियोजना स्रोत यहां हैं GitLab.

निष्कर्ष

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

वास्तविकता यह है:

सभी पाँच पीढ़ी विधियों से एक समतल पर अनुक्रमों का विज़ुअलाइज़ेशन:

और 3डी में विज़ुअलाइज़ेशन। मैं केवल System.Random.Next() का परिणाम छोड़ूंगा ताकि समान सामग्री का एक समूह उत्पन्न न हो।

UnityEngine.Random के सामान्य वितरण के बारे में परिचय में बताई गई कहानी खुद को दोहराई नहीं गई: या तो यह शुरू में गलत थी, या तब से इंजन में कुछ बदल गया है। लेकिन अब हमें यकीन है.

स्रोत: www.habr.com

BlessRNG या निष्पक्षता के लिए RNG की जाँच करना