BlessRNG किंवा निष्पक्षतेसाठी RNG तपासत आहे

गेम डेव्हलपमेंटमध्ये, तुम्हाला बऱ्याचदा यादृच्छिकतेसह काहीतरी जोडणे आवश्यक आहे: यासाठी युनिटीचे स्वतःचे रँडम आहे आणि त्याच्या समांतर सिस्टम. रँडम आहे. एकदा, एका प्रकल्पावर, मला असे समजले की दोघेही वेगळ्या पद्धतीने काम करू शकतात (जरी त्यांचे वितरण समान असले पाहिजे).

मग ते तपशिलात गेले नाहीत - हे पुरेसे होते की System.Random मध्ये संक्रमणाने सर्व समस्या दुरुस्त केल्या. आता आम्ही त्याकडे अधिक तपशीलाने पाहण्याचे आणि थोडे संशोधन करण्याचे ठरविले: "पक्षपाती" किंवा अंदाज लावता येण्याजोगे आरएनजी कसे आहेत आणि कोणते निवडायचे आहे. शिवाय, मी त्यांच्या "प्रामाणिकपणा" बद्दल एकापेक्षा जास्त वेळा परस्परविरोधी मते ऐकली आहेत - वास्तविक निकाल घोषित केलेल्यांशी कसे तुलना करतात हे शोधण्याचा प्रयत्न करूया.

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

तुम्ही यादृच्छिक क्रमांक जनरेटरशी आधीच परिचित असल्यास, तुम्ही लगेच "चाचणी" विभागात जाऊ शकता.

यादृच्छिक संख्या (RN) हा काही यादृच्छिक (अराजक) प्रक्रियेचा वापर करून व्युत्पन्न केलेल्या संख्यांचा एक क्रम आहे, जो एंट्रोपीचा स्रोत आहे. म्हणजेच, हा एक असा क्रम आहे ज्याचे घटक कोणत्याही गणितीय नियमाने एकमेकांशी जोडलेले नाहीत - त्यांच्यात कोणतेही कारण आणि परिणाम संबंध नाहीत.

यादृच्छिक संख्या जे तयार करते त्याला यादृच्छिक क्रमांक जनरेटर (RNG) म्हणतात. असे दिसते की सर्व काही प्राथमिक आहे, परंतु जर आपण सिद्धांतापासून सरावाकडे वळलो, तर खरं तर असा क्रम तयार करण्यासाठी सॉफ्टवेअर अल्गोरिदम लागू करणे इतके सोपे नाही.

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

एक अल्गोरिदम लिहिणे आवश्यक आहे जे परत येईल, जरी खरोखर यादृच्छिक संख्या नसतील, परंतु त्यांच्या शक्य तितक्या जवळ - तथाकथित स्यूडो-यादृच्छिक संख्या (पीआरएन). या प्रकरणात अल्गोरिदमला स्यूडोरँडम नंबर जनरेटर (पीआरएनजी) म्हणतात.

PRNG तयार करण्यासाठी अनेक पर्याय आहेत, परंतु खालील प्रत्येकासाठी उपयुक्त असतील:

1. प्राथमिक प्रारंभाची गरज.

   PRNG मध्ये एन्ट्रॉपीचा कोणताही स्रोत नाही, म्हणून वापरण्यापूर्वी त्यास प्रारंभिक स्थिती दिली पाहिजे. हे संख्या (किंवा वेक्टर) म्हणून निर्दिष्ट केले आहे आणि त्याला बीज (यादृच्छिक बियाणे) म्हणतात. बर्याचदा, प्रोसेसर घड्याळ काउंटर किंवा सिस्टीम वेळेच्या संख्यात्मक समतुल्य सीड म्हणून वापरले जाते.

2. अनुक्रम पुनरुत्पादनक्षमता.

   PRNG पूर्णपणे निर्धारवादी आहे, म्हणून आरंभ करताना निर्दिष्ट केलेले बीज संपूर्ण भविष्यातील संख्यांचा क्रम विशिष्टपणे निर्धारित करते. याचा अर्थ असा की समान बियाणे (वेगवेगळ्या वेळी, वेगवेगळ्या प्रोग्राममध्ये, वेगवेगळ्या उपकरणांवर) सुरू केलेला वेगळा PRNG समान क्रम तयार करेल.

तुम्हाला PRNG चे वैशिष्ट्य दर्शविणारी संभाव्यता वितरण देखील माहित असणे आवश्यक आहे - ते कोणते संख्या निर्माण करेल आणि कोणत्या संभाव्यतेसह. बहुतेकदा हे एकतर सामान्य वितरण किंवा एकसमान वितरण असते.

सामान्य वितरण (डावीकडे) आणि एकसमान वितरण (उजवीकडे)

समजा, 24 बाजूंनी आमचा पराक्रम आहे. तुम्ही टॉस केल्यास, एक मिळण्याची संभाव्यता 1/24 (इतर कोणतीही संख्या मिळण्याच्या संभाव्यतेइतकीच) असेल. जर तुम्ही अनेक थ्रो केले आणि परिणाम रेकॉर्ड केले, तर तुमच्या लक्षात येईल की सर्व कडा अंदाजे समान वारंवारतेने बाहेर पडतात. मूलत:, हे डाय एकसमान वितरणासह RNG मानले जाऊ शकते.

जर तुम्ही यापैकी 10 फासे एकाच वेळी टाकले आणि एकूण गुण मोजले तर? त्यासाठी एकसूत्रता राखली जाईल का? नाही. बऱ्याचदा, रक्कम 125 गुणांच्या जवळ असेल, म्हणजे काही सरासरी मूल्यापर्यंत. आणि परिणामी, थ्रो करण्याआधीच, आपण भविष्यातील निकालाचा अंदाज लावू शकता.

कारण सरासरी स्कोअर मिळविण्यासाठी सर्वात जास्त संयोग आहेत. त्यापासून जितके दूर, तितके कमी संयोजन - आणि त्यानुसार, तोटा होण्याची शक्यता कमी. जर हा डेटा व्हिज्युअलाइज केला असेल, तर तो अस्पष्टपणे घंटाच्या आकारासारखा दिसेल. म्हणून, काही ताणून, 10 फासे असलेल्या प्रणालीला सामान्य वितरणासह RNG म्हटले जाऊ शकते.

दुसरे उदाहरण, फक्त यावेळी विमानात - लक्ष्यावर शूटिंग. शूटर हा एक RNG असेल जो आलेखावर प्रदर्शित होणाऱ्या संख्यांची एक जोडी (x, y) तयार करतो.

सहमत आहे की डावीकडील पर्याय वास्तविक जीवनाच्या जवळ आहे - हे सामान्य वितरणासह एक आरएनजी आहे. परंतु जर तुम्हाला गडद आकाशात तारे विखुरण्याची गरज असेल, तर एकसमान वितरणासह RNG वापरून प्राप्त केलेला योग्य पर्याय अधिक योग्य आहे. सर्वसाधारणपणे, हातात असलेल्या कार्यावर अवलंबून जनरेटर निवडा.

आता PNG क्रमाच्या एन्ट्रॉपीबद्दल बोलू. उदाहरणार्थ, एक क्रम आहे जो याप्रमाणे सुरू होतो:

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, ...

विमानातही सर्व काही ठीक आहे असे दिसते:

चला व्हॉल्यूममध्ये पाहू (एकावेळी तीन संख्या वाचा):

आणि पुन्हा नमुने. चार आयामांमध्ये व्हिज्युअलायझेशन तयार करणे आता शक्य नाही. परंतु या आकारमानावर आणि मोठ्या आकारावर नमुने अस्तित्वात असू शकतात.

क्रिप्टोग्राफीमध्ये, जिथे PRNGs वर सर्वात कठोर आवश्यकता लादल्या जातात, अशी परिस्थिती स्पष्टपणे अस्वीकार्य आहे. म्हणून, त्यांच्या गुणवत्तेचे मूल्यांकन करण्यासाठी विशेष अल्गोरिदम विकसित केले गेले आहेत, ज्याला आम्ही आता स्पर्श करणार नाही. विषय विस्तृत आहे आणि स्वतंत्र लेखास पात्र आहे.

चाचणी

जर आपल्याला निश्चितपणे काहीतरी माहित नसेल, तर त्यासह कसे कार्य करावे? तुम्हाला कोणता ट्रॅफिक लाइट परवानगी देतो हे माहित नसल्यास रस्ता ओलांडणे योग्य आहे का? त्याचे परिणाम वेगळे असू शकतात.

युनिटीमधील कुख्यात यादृच्छिकतेसाठीही हेच आहे. दस्तऐवजीकरण आवश्यक तपशील प्रकट करत असल्यास ते चांगले आहे, परंतु लेखाच्या सुरुवातीला नमूद केलेली कथा इच्छित तपशीलांच्या अभावामुळे तंतोतंत घडली.

आणि जर तुम्हाला हे साधन कसे कार्य करते हे माहित नसेल, तर तुम्ही ते योग्यरित्या वापरण्यास सक्षम असणार नाही. सर्वसाधारणपणे, किमान वितरणाबाबत खात्री करून घेण्यासाठी प्रयोग तपासण्याची आणि आयोजित करण्याची वेळ आली आहे.

उपाय सोपा आणि प्रभावी होता - आकडेवारी गोळा करा, वस्तुनिष्ठ डेटा मिळवा आणि परिणाम पहा.

अभ्यासाचा विषय

युनिटीमध्ये यादृच्छिक संख्या निर्माण करण्याचे अनेक मार्ग आहेत - आम्ही पाच चाचणी केली.

1. System.Random.Next(). दिलेल्या मूल्यांच्या श्रेणीमध्ये पूर्णांक तयार करते.
2. System.Random.NextDouble(). [0 पासून श्रेणीतील दुहेरी अचूक संख्या निर्माण करते; 1).
3. UnityEngine.Random.Range(). दिलेल्या मूल्यांच्या श्रेणीमध्ये एकल अचूक संख्या (फ्लोट्स) व्युत्पन्न करते.
4. UnityEngine.Random.value. [0 पासून श्रेणीतील एकल अचूक संख्या (फ्लोट्स) व्युत्पन्न करते; 1).
5. 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

अंमलबजावणी

यादृच्छिक संख्या व्युत्पन्न करण्यासाठी आमच्याकडे अनेक भिन्न मार्ग आहेत. त्या प्रत्येकासाठी, आम्ही एक वेगळा रॅपर वर्ग लिहू, ज्याने प्रदान केले पाहिजे:

1. मूल्यांची श्रेणी सेट करण्याची शक्यता [किमान/कमाल). कन्स्ट्रक्टर द्वारे सेट केले जाईल.
2. MF परत करण्याची पद्धत. चला प्रकार म्हणून फ्लोट निवडू, कारण ते अधिक सामान्य आहे.
3. परिणाम चिन्हांकित करण्यासाठी पिढी पद्धतीचे नाव. सोयीसाठी, आम्ही मूल्य म्हणून वर्गाचे पूर्ण नाव + MF तयार करण्यासाठी वापरलेल्या पद्धतीचे नाव परत करू.

प्रथम, 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). ते कन्स्ट्रक्टरमध्ये निर्दिष्ट केलेल्या एकावर प्रक्षेपित करण्यासाठी, आम्ही साधे अंकगणित वापरतो: X * (max − min) + min.

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 चे मूल्य गुणधर्म. यादृच्छिक मूल्यांच्या निश्चित श्रेणीतून फ्लोट प्रकार मिळवते [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 ची अनेक अंमलबजावणी तयार आहे. पुढे, तुम्हाला अनुक्रमे व्युत्पन्न करणे आणि परिणामी डेटासेट प्रक्रियेसाठी जतन करणे आवश्यक आहे. हे करण्यासाठी, आम्ही युनिटीमध्ये एक देखावा आणि एक लहान मुख्य नियंत्रक स्क्रिप्ट तयार करू, जे सर्व आवश्यक कार्य करेल आणि त्याच वेळी UI सह परस्परसंवादासाठी जबाबदार असेल.

चला डेटासेटचा आकार आणि MF व्हॅल्यूजची श्रेणी सेट करूया, आणि एक पद्धत देखील मिळवा जी कॉन्फिगर केलेल्या आणि कार्य करण्यासाठी तयार जनरेटरची ॲरे देते.

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)
            };
        }

        ...
    }
}

आता डेटासेट तयार करू. या प्रकरणात, डेटा निर्मिती मजकूर प्रवाहात (csv स्वरूपात) रेकॉर्डिंगसह एकत्रित केली जाईल. प्रत्येक 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();
            }
        }

        ...
    }
}

प्रकल्पाची सूत्रे येथे आहेत गिटॅब.

निकाल

कोणताही चमत्कार घडला नाही. त्यांना जे अपेक्षित आहे तेच त्यांना मिळाले - सर्व प्रकरणांमध्ये, षड्यंत्रांच्या इशारेशिवाय समान वितरण. प्लॅटफॉर्मसाठी स्वतंत्र आलेख टाकण्यात मला मुद्दा दिसत नाही - ते सर्व अंदाजे समान परिणाम दर्शवतात.

वास्तविकता आहे:


सर्व पाच पिढीच्या पद्धतींमधून विमानावरील अनुक्रमांचे व्हिज्युअलायझेशन:


आणि 3D मध्ये व्हिज्युअलायझेशन. मी फक्त System.Random.Next() चा परिणाम सोडतो जेणेकरून एकसारख्या सामग्रीचा समूह तयार होऊ नये.


युनिटीइंजिनच्या सामान्य वितरणाविषयीच्या प्रस्तावनेत सांगितलेली कथा. यादृच्छिकपणे स्वतःची पुनरावृत्ती झाली नाही: एकतर ती सुरुवातीला चुकीची होती किंवा त्यानंतर इंजिनमध्ये काहीतरी बदलले आहे. पण आता आम्हाला खात्री आहे.

स्त्रोत: www.habr.com