BlessRNG හෝ සාධාරණත්වය සඳහා RNG පරීක්ෂා කිරීම

ක්රීඩාව සංවර්ධනය කිරීමේදී, ඔබ බොහෝ විට අහඹු ලෙස යමක් ගැටගැසීමට අවශ්ය වේ: මේ සඳහා යුනිටියට තමන්ගේම සසම්භාවී ඇත, ඊට සමාන්තරව System.Random ඇත. වරෙක, එක් ව්‍යාපෘතියකදී, දෙදෙනාම වෙනස් ලෙස ක්‍රියා කළ හැකි බවට මට හැඟීමක් ඇති විය (ඒවායේ ඉරට්ටේ බෙදා හැරීමක් තිබිය යුතු වුවද).

එවිට ඔවුන් විස්තර වෙත ගියේ නැත - System.Random වෙත සංක්රමණය වීම ප්රමාණවත් විය. දැන් අපි එය වඩාත් විස්තරාත්මකව සොයා බැලීමට සහ කුඩා පර්යේෂණයක් කිරීමට තීරණය කළෙමු: "පක්ෂග්‍රාහී" හෝ පුරෝකථනය කළ හැකි RNG යනු කෙසේද සහ තෝරා ගත යුතු දේ. එපමනක් නොව, ඔවුන්ගේ "අවංකකම" පිළිබඳ පරස්පර අදහස් මම කිහිප වතාවක් අසා ඇත - සැබෑ ප්රතිඵල ප්රකාශිත ඒවා සමඟ සැසඳෙන්නේ කෙසේදැයි සොයා ගැනීමට උත්සාහ කරමු.

කෙටි අධ්‍යාපනික වැඩසටහනක් හෝ RNG යනු ඇත්ත වශයෙන්ම RNG වේ

ඔබ දැනටමත් අහඹු සංඛ්යා උත්පාදක යන්ත්ර සමඟ හුරුපුරුදු නම්, ඔබට වහාම "පරීක්ෂා කිරීම" කොටස වෙත යා හැක.

සසම්භාවී සංඛ්‍යා (RN) යනු එන්ට්‍රොපි ප්‍රභවයක් වන යම් අහඹු (අවුල් සහගත) ක්‍රියාවලියක් භාවිතයෙන් ජනනය කරන ලද සංඛ්‍යා අනුපිළිවෙලකි. එනම්, මෙය කිසිදු ගණිතමය නීතියකින් එකිනෙකට සම්බන්ධ නොවන මූලද්‍රව්‍ය අනුපිළිවෙලකි - ඒවාට හේතු සහ ඵල සම්බන්ධයක් නොමැත.

සසම්භාවී අංකය නිර්මාණය කරන දෙය සසම්භාවී සංඛ්‍යා උත්පාදකයක් (RNG) ලෙස හැඳින්වේ. සෑම දෙයක්ම මූලික බව පෙනේ, නමුත් අපි න්‍යායෙන් ප්‍රායෝගිකව ගමන් කරන්නේ නම්, ඇත්ත වශයෙන්ම එවැනි අනුපිළිවෙලක් ජනනය කිරීම සඳහා මෘදුකාංග ඇල්ගොරිතමයක් ක්‍රියාත්මක කිරීම එතරම් සරල නැත.

හේතුව නවීන පාරිභෝගික ඉලෙක්ට්‍රොනික උපකරණවල එම අවුල් සහගත තත්ත්වය නොමැති වීමයි. එසේ නොමැතිව අහඹු සංඛ්‍යා අහඹු වීම නවත්වන අතර, ඒවායේ උත්පාදක යන්ත්‍රය පැහැදිලිවම අර්ථ දක්වා ඇති තර්කවල සාමාන්‍ය ශ්‍රිතයක් බවට පත් වේ. තොරතුරු තාක්ෂණ ක්ෂේත්රයේ විශේෂතා ගණනාවක් සඳහා, මෙය බරපතල ගැටළුවක් (උදාහරණයක් ලෙස, ගුප්තකේතනය), නමුත් අනෙක් අයට සම්පූර්ණයෙන්ම පිළිගත හැකි විසඳුමක් තිබේ.

සත්‍ය වශයෙන්ම අහඹු සංඛ්‍යා නොව, නමුත් ඒවාට හැකි තරම් සමීප - ඊනියා ව්‍යාජ අහඹු සංඛ්‍යා (PRN) නැවත පැමිණෙන ඇල්ගොරිතමයක් ලිවීම අවශ්‍ය වේ. මෙම නඩුවේ ඇල්ගොරිතම ව්යාජ සංඛ්යා උත්පාදක (PRNG) ලෙස හැඳින්වේ.

PRNG නිර්මාණය කිරීම සඳහා විකල්ප කිහිපයක් ඇත, නමුත් පහත සඳහන් දේ සෑම කෙනෙකුටම අදාළ වේ:

1. ප්රාථමික ආරම්භ කිරීම සඳහා අවශ්යතාවය.

   PRNG හට එන්ට්‍රොපි ප්‍රභවයක් නොමැත, එබැවින් එය භාවිතයට පෙර ආරම්භක තත්වයක් ලබා දිය යුතුය. එය අංකයක් (හෝ දෛශිකයක්) ලෙස දක්වා ඇති අතර එය බීජයක් (අහඹු බීජ) ලෙස හැඳින්වේ. බොහෝ විට, ප්‍රොසෙසර ඔරලෝසු කවුන්ටරය හෝ පද්ධති කාලයෙහි සංඛ්‍යාත්මක සමානකම බීජයක් ලෙස භාවිතා කරයි.

2. අනුපිළිවෙල ප්රතිනිෂ්පාදනය.

   PRNG සම්පූර්ණයෙන්ම නිර්ණායක වේ, එබැවින් ආරම්භයේදී නියම කරන ලද බීජය මුළු අනාගත සංඛ්‍යා අනුපිළිවෙලම අද්විතීය ලෙස තීරණය කරයි. මෙයින් අදහස් කරන්නේ එකම බීජයකින් (විවිධ කාලවලදී, විවිධ වැඩසටහන් වල, විවිධ උපාංගවල) ආරම්භ කරන ලද වෙනම PRNG එකම අනුපිළිවෙලක් ජනනය කරන බවයි.

PRNG සංලක්ෂිත සම්භාවිතා ව්‍යාප්තිය ද ඔබ දැනගත යුතුය - එය ජනනය කරන්නේ කුමන සංඛ්‍යා සහ කුමන සම්භාවිතාව සමඟද. බොහෝ විට මෙය සාමාන්ය බෙදාහැරීමක් හෝ ඒකාකාර බෙදාහැරීමක් වේ.

සාමාන්‍ය ව්‍යාප්තිය (වමේ) සහ ඒකාකාර ව්‍යාප්තිය (දකුණ)

අපි හිතමු අපිට පැති 24ක් තියෙන සාධාරණ මරණයක් තියෙනවා කියලා. ඔබ එය විසි කළහොත්, එකක් ලබා ගැනීමේ සම්භාවිතාව 1/24 ට සමාන වේ (වෙනත් ඕනෑම අංකයක් ලබා ගැනීමේ සම්භාවිතාවට සමාන වේ). ඔබ බොහෝ විසි කිරීම් සිදු කර ප්‍රතිඵල වාර්තා කරන්නේ නම්, සියලුම දාර ආසන්න වශයෙන් එකම සංඛ්‍යාතයකින් වැටෙන බව ඔබට පෙනෙනු ඇත. අත්යවශ්යයෙන්ම, මෙම ඩයි එක ඒකාකාර ව්යාප්තියක් සහිත RNG ලෙස සැලකිය හැකිය.

ඔබ මෙම දාදු කැට 10 ක් එකවර විසි කර මුළු ලකුණු ගණන් කළහොත් කුමක් කළ යුතුද? ඒ සඳහා ඒකාකාරී බව රැකෙයිද? නැත. බොහෝ විට, මුදල ලකුණු 125 ට ආසන්න වනු ඇත, එනම්, යම් සාමාන්ය අගයකට. එහි ප්‍රතිඵලයක් වශයෙන්, විසි කිරීමක් කිරීමට පෙර පවා, ඔබට අනාගත ප්‍රතිඵලය දළ වශයෙන් තක්සේරු කළ හැකිය.

හේතුව සාමාන්‍ය ලකුණු ලබා ගැනීම සඳහා වැඩිම සංයෝජන සංඛ්‍යාවක් තිබීමයි. එය දුරින්, අඩු සංයෝජන - සහ, ඒ අනුව, අලාභයේ සම්භාවිතාව අඩු වේ. මෙම දත්ත දෘශ්‍යමාන කළහොත්, එය නොපැහැදිලි ලෙස සීනුවක හැඩයට සමාන වේ. එබැවින්, යම් දිගුවක් සහිතව, ඩයිස් 10 ක පද්ධතියක් සාමාන්ය ව්යාප්තියක් සහිත RNG ලෙස හැඳින්විය හැක.

තවත් උදාහරණයක්, මේ වතාවේ ගුවන් යානයක පමණක් - ඉලක්කයකට වෙඩි තැබීම. වෙඩික්කරු RNG එකක් වන අතර එය ප්‍රස්ථාරයේ සංදර්ශන වන අංක යුගලයක් (x, y) ජනනය කරයි.

වම් පස ඇති විකල්පය සැබෑ ජීවිතයට සමීප බව එකඟ වන්න - මෙය සාමාන්ය බෙදාහැරීමක් සහිත 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 මත වඩාත් දැඩි අවශ්‍යතා පනවා ඇති ගුප්ත ලේඛන විද්‍යාවේදී, එවැනි තත්වයක් නිශ්චිතවම පිළිගත නොහැකිය. එබැවින්, ඒවායේ ගුණාත්මකභාවය තක්සේරු කිරීම සඳහා විශේෂ ඇල්ගොරිතම සකස් කර ඇත, අපි දැන් එය ස්පර්ශ නොකරනු ඇත. මාතෘකාව පුළුල් වන අතර වෙනම ලිපියක් ලැබිය යුතුය.

පරීක්ෂා කිරීම

අපි නිශ්චිතවම යමක් නොදන්නේ නම්, එය සමඟ වැඩ කරන්නේ කෙසේද? කුමන රථවාහන ආලෝකය එයට ඉඩ දෙන්නේදැයි ඔබ නොදන්නේ නම් මාර්ගය තරණය කිරීම වටී ද? ප්රතිවිපාක වෙනස් විය හැකිය.

Unity හි ඇති කුප්‍රකට අහඹුකමද එසේමය. ලියකියවිලි අවශ්‍ය තොරතුරු හෙළි කරන්නේ නම් හොඳයි, නමුත් ලිපියේ ආරම්භයේ සඳහන් කළ කතාව හරියටම සිදු වූයේ අපේක්ෂිත විශේෂතා නොමැතිකම නිසාය.

මෙවලම ක්‍රියා කරන්නේ කෙසේදැයි ඔබ නොදන්නේ නම්, ඔබට එය නිවැරදිව භාවිතා කිරීමට නොහැකි වනු ඇත. පොදුවේ ගත් කල, අවම වශයෙන් බෙදා හැරීම පිළිබඳව සහතික කර ගැනීම සඳහා පරීක්ෂා කර අත්හදා බැලීමක් කිරීමට කාලය පැමිණ තිබේ.

විසඳුම සරල හා ඵලදායී විය - සංඛ්යා ලේඛන එකතු කිරීම, වෛෂයික දත්ත ලබා ගැනීම සහ ප්රතිඵල දෙස බැලීම.

අධ්යයන විෂයය

Unity හි අහඹු සංඛ්‍යා ජනනය කිරීමට ක්‍රම කිහිපයක් තිබේ - අපි පහක් පරීක්ෂා කළෙමු.

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 සඳහා
  — Unity v2018.3.14f1, Editor mode, Mono, .NET Standard 2.0
• macOS
  — Unity v2018.3.14f1, Editor mode, Mono, .NET Standard 2.0
  — Unity v5.6.4p4, Editor mode, Mono, .NET Standard 2.0
• ඇන්ඩ්රොයිඩ්
  — Unity v2018.3.14f1, build per device, Mono, .NET Standard 2.0
• , iOS
  — Unity v2018.3.14f1, build per device, il2cpp, .NET Standard 2.0

Реализация

අහඹු සංඛ්‍යා ජනනය කිරීමට අපට විවිධ ක්‍රම කිහිපයක් තිබේ. ඒ සෑම එකක් සඳහාම, අපි වෙනම දවටන පන්තියක් ලියන්නෙමු, එය සැපයිය යුතුය:

1. අගයන් පරාසය සැකසීමේ හැකියාව [min/max). ඉදිකිරීම්කරු හරහා සකසනු ඇත.
2. MF ආපසු ලබා දෙන ක්රමය. එය වඩාත් පොදු වන බැවින්, වර්ගය ලෙස float තෝරා ගනිමු.
3. ප්රතිඵල ලකුණු කිරීම සඳහා උත්පාදන ක්රමයේ නම. පහසුව සඳහා, අපි පන්තියේ සම්පූර්ණ නම + MF ජනනය කිරීමට භාවිතා කරන ක්‍රමයේ නම අගයක් ලෙස ලබා දෙන්නෙමු.

පළමුව, IrandomGenerator අතුරුමුහුණත මගින් නිරූපණය කෙරෙන වියුක්තයක් ප්‍රකාශ කරමු:

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

        float Generate();
    }
}

System.Random.Next() ක්‍රියාත්මක කිරීම

මෙම ක්‍රමය මඟින් ඔබට අගයන් පරාසයක් සැකසීමට ඉඩ සලසයි, නමුත් එය පූර්ණ සංඛ්‍යා ලබා දෙයි, නමුත් පාවෙන අවශ්‍ය වේ. ඔබට පූර්ණ සංඛ්‍යාව පාවෙන ලෙස අර්ථ දැක්විය හැකිය, නැතහොත් ඔබට අගයන් පරාසය විශාලත්වයේ ඇණවුම් කිහිපයකින් පුළුල් කළ හැකිය, මධ්‍යම පරාසයේ එක් එක් පරම්පරාව සමඟ ඒවාට වන්දි ලබා දේ. ප්‍රතිඵලය වනු ඇත්තේ දී ඇති නිරවද්‍යතාවයේ අනුපිළිවෙලක් සහිත ස්ථාවර ලක්ෂ්‍යයක් වැනි දෙයකි. එය සැබෑ float අගයට ආසන්න බැවින් අපි මෙම විකල්පය භාවිතා කරන්නෙමු.

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 * (උපරිම - 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 static class හි මෙම ක්‍රමය මඟින් ඔබට අගයන් පරාසයක් සැකසීමට සහ පාවෙන වර්ගයක් ලබා දීමට ඉඩ සලසයි. ඔබට අමතර පරිවර්තනයක් කිරීමට අවශ්‍ය නැත.

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

MainController ක්‍රියාත්මක කිරීම

IrandomGenerator ක්‍රියාත්මක කිරීම් කිහිපයක් සූදානම්. ඊළඟට, ඔබ විසින් අනුපිළිවෙලවල් උත්පාදනය කළ යුතු අතර, සැකසීම සඳහා ප්රතිඵල දත්ත කට්ටලය සුරැකිය යුතුය. මෙය සිදු කිරීම සඳහා, අපි Unity හි දර්ශනයක් සහ කුඩා MainController ස්ක්‍රිප්ට් එකක් සාදනු ඇත, එය අවශ්‍ය සියලුම කාර්යයන් ඉටු කරන අතර ඒ සමඟම 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 ක්‍රමය ඇමතීමට සහ ප්‍රති result ලය ගොනුවකට සුරැකීම හෝ වහාම ජාලය හරහා දත්ත අවසන් උපාංගයෙන් ලැබෙන සේවාදායකයට මාරු කිරීම පමණි.

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