બ્લેસઆરએનજી અથવા વાજબીતા માટે આરએનજી તપાસો

રમતના વિકાસમાં, તમારે ઘણીવાર રેન્ડમનેસ સાથે કંઈક બાંધવાની જરૂર છે: આ માટે યુનિટીનું પોતાનું રેન્ડમ છે, અને તેની સમાંતર સિસ્ટમ. રેન્ડમ છે. એક સમયે, એક પ્રોજેક્ટ પર, મને એવી છાપ મળી કે બંને અલગ રીતે કામ કરી શકે છે (જોકે તેમની પાસે સમાન વિતરણ હોવું જોઈએ).

પછી તેઓ વિગતોમાં ગયા નહીં - તે પૂરતું હતું કે સિસ્ટમમાં સંક્રમણ. રેન્ડમ બધી સમસ્યાઓ સુધારે છે. હવે અમે તેને વધુ વિગતમાં જોવાનું અને થોડું સંશોધન કરવાનું નક્કી કર્યું: "પક્ષપાતી" અથવા અનુમાનિત RNGs કેટલા છે અને કયો પસંદ કરવો. તદુપરાંત, મેં તેમની "પ્રામાણિકતા" વિશે વિરોધાભાસી મંતવ્યો એક કરતા વધુ વાર સાંભળ્યા છે - ચાલો એ શોધવાનો પ્રયાસ કરીએ કે વાસ્તવિક પરિણામો જાહેર કરેલા પરિણામો સાથે કેવી રીતે સરખાવે છે.

સંક્ષિપ્ત શૈક્ષણિક કાર્યક્રમ અથવા RNG વાસ્તવમાં RNG છે

જો તમે પહેલાથી જ રેન્ડમ નંબર જનરેટર્સથી પરિચિત છો, તો તમે તરત જ "પરીક્ષણ" વિભાગ પર જઈ શકો છો.

રેન્ડમ નંબર્સ (RN) એ કેટલીક રેન્ડમ (અસ્તવ્યસ્ત) પ્રક્રિયાનો ઉપયોગ કરીને પેદા થયેલ સંખ્યાઓનો ક્રમ છે, જે એન્ટ્રોપીનો સ્ત્રોત છે. એટલે કે, આ એક એવો ક્રમ છે કે જેના તત્વો કોઈપણ ગાણિતિક કાયદા દ્વારા એકબીજા સાથે જોડાયેલા નથી - તેમની પાસે કોઈ કારણ અને અસર સંબંધ નથી.

જે રેન્ડમ નંબર બનાવે છે તેને રેન્ડમ નંબર જનરેટર (RNG) કહેવાય છે. એવું લાગે છે કે બધું પ્રાથમિક છે, પરંતુ જો આપણે સિદ્ધાંતથી પ્રેક્ટિસ તરફ આગળ વધીએ, તો હકીકતમાં આવા ક્રમ બનાવવા માટે સોફ્ટવેર અલ્ગોરિધમનો અમલ કરવો એટલું સરળ નથી.

કારણ આધુનિક ગ્રાહક ઇલેક્ટ્રોનિક્સમાં સમાન અરાજકતાની ગેરહાજરીમાં રહેલું છે. તેના વિના, રેન્ડમ નંબરો રેન્ડમ બનવાનું બંધ કરે છે, અને તેમનું જનરેટર સ્પષ્ટ રીતે વ્યાખ્યાયિત દલીલોના સામાન્ય કાર્યમાં ફેરવાય છે. આઇટી ક્ષેત્રની સંખ્યાબંધ વિશેષતાઓ માટે, આ એક ગંભીર સમસ્યા છે (ઉદાહરણ તરીકે, સંકેતલિપી), પરંતુ અન્ય લોકો માટે સંપૂર્ણપણે સ્વીકાર્ય ઉકેલ છે.

એલ્ગોરિધમ લખવું જરૂરી છે કે જે ખરેખર રેન્ડમ નંબરો ન હોવા છતાં, પરત આવશે, પરંતુ તેમની શક્ય તેટલી નજીક - કહેવાતા સ્યુડો-રેન્ડમ નંબર્સ (પીઆરએન). આ કિસ્સામાં અલ્ગોરિધમને સ્યુડોરેન્ડમ નંબર જનરેટર (PRNG) કહેવામાં આવે છે.

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

પ્રથમ નજરમાં આ સંખ્યાઓ કેટલી રેન્ડમ છે? ચાલો વિતરણ તપાસીને શરૂ કરીએ.

તે એકસમાનની નજીક લાગે છે, પરંતુ જો તમે બે સંખ્યાઓનો ક્રમ વાંચો અને તેમને પ્લેન પર કોઓર્ડિનેટ્સ તરીકે અર્થઘટન કરો, તો તમને આ મળશે:

પેટર્ન સ્પષ્ટપણે દૃશ્યમાન બને છે. અને ત્યારથી ક્રમમાંનો ડેટા ચોક્કસ રીતે ઓર્ડર કરવામાં આવ્યો છે (એટલે ​​​​કે, તેની એન્ટ્રોપી ઓછી છે), આ તે ખૂબ જ "પૂર્વગ્રહ" ને જન્મ આપી શકે છે. ઓછામાં ઓછા, આવા 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, ...

પ્લેનમાં પણ અહીં બધું સારું લાગે છે:

ચાલો વોલ્યુમમાં જોઈએ (એક સમયે ત્રણ સંખ્યાઓ વાંચો):

અને ફરીથી પેટર્ન. ચાર પરિમાણમાં વિઝ્યુલાઇઝેશન બનાવવું હવે શક્ય નથી. પરંતુ પેટર્ન આ પરિમાણ પર અને મોટા પર અસ્તિત્વમાં હોઈ શકે છે.

ક્રિપ્ટોગ્રાફીમાં, જ્યાં 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) છે.

કેટલાક લક્ષ્ય પ્લેટફોર્મ પરથી ડેટા એકત્રિત કરવામાં આવ્યો હતો:

• વિન્ડોઝ
  — Unity v2018.3.14f1, એડિટર મોડ, મોનો, .NET સ્ટાન્ડર્ડ 2.0
• MacOS
  — Unity v2018.3.14f1, એડિટર મોડ, મોનો, .NET સ્ટાન્ડર્ડ 2.0
  — યુનિટી v5.6.4p4, એડિટર મોડ, મોનો, .NET સ્ટાન્ડર્ડ 2.0
• , Android
  — Unity v2018.3.14f1, ઉપકરણ દીઠ બિલ્ડ, Mono, .NET ધોરણ 2.0
• iOS
  — Unity 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 ક્લાસની 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 ના સામાન્ય વિતરણ વિશેની પરિચયમાં કહેવામાં આવેલી વાર્તા. રેન્ડમ પોતાને પુનરાવર્તિત કરતું નથી: કાં તો તે શરૂઆતમાં ભૂલભરેલું હતું, અથવા ત્યારથી એન્જિનમાં કંઈક બદલાયું છે. પરંતુ હવે અમને ખાતરી છે.

સોર્સ: www.habr.com