RNGని ఆశీర్వదించండి లేదా సరసత కోసం RNGని తనిఖీ చేయండి

గేమ్ డెవలప్‌మెంట్‌లో, మీరు తరచుగా యాదృచ్ఛికతతో ఏదైనా కట్టాలి: దీని కోసం యూనిటీకి దాని స్వంత యాదృచ్ఛికం ఉంది మరియు దానితో సమాంతరంగా System.Random ఉంది. ఒకప్పుడు, ప్రాజెక్ట్‌లలో ఒకదానిపై, రెండూ వేర్వేరుగా పని చేయగలవు అనే అభిప్రాయాన్ని నేను పొందాను (అయితే అవి సమాన పంపిణీని కలిగి ఉండాలి).

అప్పుడు వారు వివరాల్లోకి వెళ్లలేదు - సిస్టమ్‌కు పరివర్తన చెందడం సరిపోతుంది.రాండమ్ అన్ని సమస్యలను సరిదిద్దింది. ఇప్పుడు మేము దానిని మరింత వివరంగా పరిశీలించి, కొద్దిగా పరిశోధన చేయాలని నిర్ణయించుకున్నాము: "పక్షపాతం" లేదా ఊహాజనిత RNGలు ఎలా ఉన్నాయి మరియు ఏది ఎంచుకోవాలి. అంతేకాకుండా, వారి “నిజాయితీ” గురించి నేను ఒకటి కంటే ఎక్కువసార్లు వివాదాస్పద అభిప్రాయాలను విన్నాను - నిజమైన ఫలితాలు ప్రకటించిన వాటితో ఎలా పోలుస్తాయో గుర్తించడానికి ప్రయత్నిద్దాం.

సంక్షిప్త విద్యా కార్యక్రమం లేదా RNG నిజానికి RNG

మీకు ఇప్పటికే యాదృచ్ఛిక సంఖ్య జనరేటర్లు బాగా తెలిసి ఉంటే, మీరు వెంటనే "టెస్టింగ్" విభాగానికి దాటవేయవచ్చు.

యాదృచ్ఛిక సంఖ్యలు (RN) అనేది ఎంట్రోపీకి మూలమైన కొన్ని యాదృచ్ఛిక (అస్తవ్యస్తమైన) ప్రక్రియను ఉపయోగించి సృష్టించబడిన సంఖ్యల శ్రేణి. అంటే, ఇది ఏదైనా గణిత చట్టం ద్వారా పరస్పర అనుసంధానించబడిన మూలకాలు లేని క్రమం - వాటికి కారణం మరియు ప్రభావ సంబంధం లేదు.

యాదృచ్ఛిక సంఖ్యను సృష్టించే దానిని యాదృచ్ఛిక సంఖ్య జనరేటర్ (RNG) అంటారు. ప్రతిదీ ప్రాథమికంగా ఉన్నట్లు అనిపిస్తుంది, కానీ మనం సిద్ధాంతం నుండి అభ్యాసానికి వెళితే, వాస్తవానికి అటువంటి క్రమాన్ని రూపొందించడానికి సాఫ్ట్‌వేర్ అల్గోరిథంను అమలు చేయడం అంత సులభం కాదు.

ఆధునిక వినియోగదారు ఎలక్ట్రానిక్స్‌లో అదే గందరగోళం లేకపోవడం దీనికి కారణం. అది లేకుండా, యాదృచ్ఛిక సంఖ్యలు యాదృచ్ఛికంగా నిలిచిపోతాయి మరియు వాటి జనరేటర్ స్పష్టంగా నిర్వచించబడిన వాదనల యొక్క సాధారణ ఫంక్షన్‌గా మారుతుంది. IT రంగంలోని అనేక ప్రత్యేకతల కోసం, ఇది తీవ్రమైన సమస్య (ఉదాహరణకు, క్రిప్టోగ్రఫీ), కానీ ఇతరులకు పూర్తిగా ఆమోదయోగ్యమైన పరిష్కారం ఉంది.

నిజంగా యాదృచ్ఛిక సంఖ్యలు కానప్పటికీ, వాటికి వీలైనంత దగ్గరగా - సూడో-రాండమ్ నంబర్లు (PRN) అని పిలవబడే అల్గోరిథంను వ్రాయడం అవసరం. ఈ సందర్భంలో అల్గోరిథంను సూడోరాండమ్ నంబర్ జనరేటర్ (PRNG) అంటారు.

PRNGని సృష్టించడానికి అనేక ఎంపికలు ఉన్నాయి, కానీ కిందివి అందరికీ సంబంధించినవిగా ఉంటాయి:

1. ప్రాథమిక ప్రారంభ అవసరం.

   PRNGకి ఎంట్రోపీ యొక్క మూలం లేదు, కాబట్టి దానిని ఉపయోగించే ముందు తప్పనిసరిగా ప్రారంభ స్థితిని ఇవ్వాలి. ఇది సంఖ్య (లేదా వెక్టర్)గా పేర్కొనబడింది మరియు దీనిని విత్తనం (యాదృచ్ఛిక విత్తనం) అంటారు. తరచుగా, ప్రాసెసర్ క్లాక్ కౌంటర్ లేదా సిస్టమ్ సమయానికి సమానమైన సంఖ్యను సీడ్‌గా ఉపయోగిస్తారు.

2. క్రమం పునరుత్పత్తి.

   PRNG పూర్తిగా నిర్ణయాత్మకమైనది, కాబట్టి ప్రారంభ సమయంలో పేర్కొన్న విత్తనం మొత్తం భవిష్యత్ సంఖ్యల క్రమాన్ని ప్రత్యేకంగా నిర్ణయిస్తుంది. అంటే ఒకే సీడ్‌తో (వేర్వేరు సమయాల్లో, వేర్వేరు ప్రోగ్రామ్‌లలో, వేర్వేరు పరికరాల్లో) ప్రారంభించబడిన ప్రత్యేక PRNG అదే క్రమాన్ని ఉత్పత్తి చేస్తుంది.

మీరు PRNGని వర్గీకరించే సంభావ్యత పంపిణీని కూడా తెలుసుకోవాలి - ఇది ఏ సంఖ్యలను ఉత్పత్తి చేస్తుంది మరియు ఏ సంభావ్యతతో ఉంటుంది. చాలా తరచుగా ఇది సాధారణ పంపిణీ లేదా ఏకరీతి పంపిణీ.

సాధారణ పంపిణీ (ఎడమ) మరియు ఏకరూప పంపిణీ (కుడి)

మనకు 24 భుజాలతో న్యాయమైన డై ఉందని చెప్పండి. మీరు దానిని టాస్ చేస్తే, ఒకదాన్ని పొందే సంభావ్యత 1/24కి సమానంగా ఉంటుంది (ఏదైనా ఇతర సంఖ్యను పొందే సంభావ్యత వలె). మీరు అనేక త్రోలు చేసి ఫలితాలను రికార్డ్ చేస్తే, అన్ని అంచులు దాదాపు ఒకే పౌనఃపున్యంతో పడిపోవడాన్ని మీరు గమనించవచ్చు. ముఖ్యంగా, ఈ డైని ఏకరీతి పంపిణీతో RNGగా పరిగణించవచ్చు.

మీరు వీటిలో 10 పాచికలను ఒకేసారి విసిరి మొత్తం పాయింట్లను లెక్కించినట్లయితే? దానికి ఏకరూపత కొనసాగుతుందా? నం. చాలా తరచుగా, మొత్తం 125 పాయింట్లకు దగ్గరగా ఉంటుంది, అంటే కొంత సగటు విలువ. మరియు ఫలితంగా, త్రో చేయడానికి ముందు, మీరు భవిష్యత్తు ఫలితాన్ని సుమారుగా అంచనా వేయవచ్చు.

కారణం ఏమిటంటే, సగటు స్కోర్‌ను పొందేందుకు అత్యధిక సంఖ్యలో కాంబినేషన్‌లు ఉన్నాయి. దాని నుండి దూరంగా, తక్కువ కలయికలు - మరియు, తదనుగుణంగా, నష్టం యొక్క సంభావ్యత తక్కువగా ఉంటుంది. ఈ డేటా దృశ్యమానం చేయబడితే, అది అస్పష్టంగా గంట ఆకారాన్ని పోలి ఉంటుంది. అందువల్ల, కొంత సాగదీయడంతో, 10 పాచికల వ్యవస్థను సాధారణ పంపిణీతో RNG అని పిలుస్తారు.

మరొక ఉదాహరణ, ఈసారి మాత్రమే విమానంలో - లక్ష్యం వద్ద షూటింగ్. షూటర్ అనేది గ్రాఫ్‌లో ప్రదర్శించబడే ఒక జత సంఖ్యలను (x, y) రూపొందించే RNG.

ఎడమవైపు ఉన్న ఎంపిక నిజ జీవితానికి దగ్గరగా ఉందని అంగీకరిస్తున్నారు - ఇది సాధారణ పంపిణీతో కూడిన RNG. కానీ మీరు చీకటి ఆకాశంలో నక్షత్రాలను చెదరగొట్టాల్సిన అవసరం ఉంటే, ఏకరీతి పంపిణీతో 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, ...

మొదటి చూపులో ఈ సంఖ్యలు ఎంత యాదృచ్ఛికంగా ఉన్నాయి? పంపిణీని తనిఖీ చేయడం ద్వారా ప్రారంభిద్దాం.

ఇది ఏకరూపానికి దగ్గరగా కనిపిస్తుంది, కానీ మీరు రెండు సంఖ్యల క్రమాన్ని చదివి, వాటిని విమానంలో కోఆర్డినేట్‌లుగా అర్థం చేసుకుంటే, మీరు దీన్ని పొందుతారు:

నమూనాలు స్పష్టంగా కనిపిస్తాయి. సీక్వెన్స్‌లోని డేటా ఒక నిర్దిష్ట మార్గంలో ఆర్డర్ చేయబడినందున (అంటే, ఇది తక్కువ ఎంట్రోపీని కలిగి ఉంటుంది), ఇది చాలా “పక్షపాతం”కి దారి తీస్తుంది. కనీసం, అటువంటి PRNG విమానంలో కోఆర్డినేట్‌లను రూపొందించడానికి చాలా సరిఅయినది కాదు.

మరొక క్రమం:

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

విమానంలో కూడా ఇక్కడ అంతా బాగానే ఉంది:

వాల్యూమ్‌లో చూద్దాం (ఒకేసారి మూడు సంఖ్యలను చదవండి):

మరియు మళ్ళీ నమూనాలు. ఇకపై నాలుగు కోణాల్లో విజువలైజేషన్‌ను నిర్మించడం సాధ్యం కాదు. కానీ ఈ పరిమాణంలో మరియు పెద్ద వాటిపై నమూనాలు ఉండవచ్చు.

క్రిప్టోగ్రఫీలో, PRNGలపై అత్యంత కఠినమైన అవసరాలు విధించబడినప్పుడు, అటువంటి పరిస్థితి వర్గీకరణపరంగా ఆమోదయోగ్యం కాదు. అందువల్ల, వాటి నాణ్యతను అంచనా వేయడానికి ప్రత్యేక అల్గోరిథంలు అభివృద్ధి చేయబడ్డాయి, వీటిని మేము ఇప్పుడు తాకము. అంశం విస్తృతమైనది మరియు ప్రత్యేక కథనానికి అర్హమైనది.

పరీక్ష

మనకు ఖచ్చితంగా ఏదైనా తెలియకపోతే, దానితో ఎలా పని చేయాలి? ఏ ట్రాఫిక్ లైట్ అనుమతిస్తుందో మీకు తెలియకపోతే రోడ్డు దాటడం విలువైనదేనా? పరిణామాలు భిన్నంగా ఉండవచ్చు.

యూనిటీలో అపఖ్యాతి పాలైన యాదృచ్ఛికతకు కూడా ఇది వర్తిస్తుంది. డాక్యుమెంటేషన్ అవసరమైన వివరాలను వెల్లడిస్తే మంచిది, కానీ కథనం ప్రారంభంలో పేర్కొన్న కథ కావలసిన ప్రత్యేకతలు లేకపోవడం వల్ల ఖచ్చితంగా జరిగింది.

మరియు సాధనం ఎలా పనిచేస్తుందో మీకు తెలియకపోతే, మీరు దాన్ని సరిగ్గా ఉపయోగించలేరు. సాధారణంగా, కనీసం పంపిణీ గురించి అయినా నిర్ధారించుకోవడానికి ఒక ప్రయోగాన్ని తనిఖీ చేయడానికి మరియు నిర్వహించడానికి సమయం ఆసన్నమైంది.

పరిష్కారం సరళమైనది మరియు ప్రభావవంతమైనది - గణాంకాలను సేకరించండి, ఆబ్జెక్టివ్ డేటాను పొందండి మరియు ఫలితాలను చూడండి.

అధ్యయనం యొక్క విషయం

యూనిటీలో యాదృచ్ఛిక సంఖ్యలను రూపొందించడానికి అనేక మార్గాలు ఉన్నాయి - మేము ఐదు పరీక్షించాము.

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

అనేక లక్ష్య ప్లాట్‌ఫారమ్‌ల నుండి డేటా సేకరించబడింది:

• విండోస్
  — యూనిటీ v2018.3.14f1, ఎడిటర్ మోడ్, మోనో, .NET స్టాండర్డ్ 2.0
• MacOS
  — యూనిటీ v2018.3.14f1, ఎడిటర్ మోడ్, మోనో, .NET స్టాండర్డ్ 2.0
  — యూనిటీ v5.6.4p4, ఎడిటర్ మోడ్, మోనో, .NET స్టాండర్డ్ 2.0
• ఆండ్రాయిడ్
  — యూనిటీ 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 * (గరిష్టంగా - నిమి) + నిమి.

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 class యొక్క 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();
            }
        }

        ...
    }
}

ప్రాజెక్ట్ మూలాలు ఉన్నాయి GitLab.

Результаты

అద్భుతం జరగలేదు. వారు ఆశించినది వారు పొందారు - అన్ని సందర్భాల్లో, కుట్రల సూచన లేకుండా సమాన పంపిణీ. ప్లాట్‌ఫారమ్‌ల కోసం వేర్వేరు గ్రాఫ్‌లను ఉంచడంలో నాకు అర్థం లేదు - అవన్నీ దాదాపు ఒకే ఫలితాలను చూపుతాయి.

వాస్తవం ఏమిటంటే:


మొత్తం ఐదు తరం పద్ధతుల నుండి విమానంలో సన్నివేశాల దృశ్యమానం:


మరియు 3Dలో విజువలైజేషన్. నేను System.Random.Next() యొక్క ఫలితాన్ని మాత్రమే వదిలివేస్తాను, తద్వారా ఒకే విధమైన కంటెంట్‌ను ఉత్పత్తి చేయకూడదు.


UnityEngine.Random యొక్క సాధారణ పంపిణీ గురించి ఉపోద్ఘాతంలో చెప్పిన కథ పునరావృతం కాలేదు: ఇది మొదట్లో తప్పుగా ఉంది లేదా ఇంజిన్‌లో ఏదో మార్పు వచ్చింది. కానీ ఇప్పుడు మేము ఖచ్చితంగా ఉన్నాము.

మూలం: www.habr.com