တရားမျှတမှုအတွက် BlessRNG သို့မဟုတ် RNG ကိုစစ်ဆေးပါ။

ဂိမ်းတည်ဆောက်မှုတွင်၊ သင်သည် ကျပန်းတစ်ခုခုနှင့် မကြာခဏ ချိတ်ဆက်ရန် လိုအပ်သည်- Unity သည် ၎င်းအတွက် ကိုယ်ပိုင် Random ရှိပြီး ၎င်းနှင့်အပြိုင် System.Random ရှိသည်။ တစ်ချိန်က ပရောဂျက်တစ်ခုတွင်၊ နှစ်ခုလုံးသည် ကွဲပြားစွာအလုပ်လုပ်နိုင်သည် (၎င်းတို့သည် ဖြန့်ဖြူးမှုတစ်ခုမျှသာရှိသင့်သော်လည်း) တစ်ချိန်က ကျွန်တော်ခံစားခဲ့ရပါသည်။

ထို့နောက် ၎င်းတို့သည် အသေးစိတ်အချက်အလက်များကို နားမလည်ခဲ့ပါ - System.Random သို့ ကူးပြောင်းခြင်းသည် ပြဿနာအားလုံးကို ပြုပြင်ပေးသည်နှင့် လုံလောက်ပါသည်။ ယခု ကျွန်ုပ်တို့သည် ၎င်းကို အသေးစိတ်ကြည့်ရှုပြီး သုတေသနအနည်းငယ်ပြုလုပ်ရန် ဆုံးဖြတ်ခဲ့သည်- မည်မျှ "ဘက်လိုက်သည်" သို့မဟုတ် ကြိုတင်ခန့်မှန်းနိုင်သော RNG များဖြစ်ပြီး မည်သည့်အရာကို ရွေးချယ်မည်နည်း။ ထို့အပြင်၊ ၎င်းတို့၏ "ရိုးသားမှု" နှင့် ပတ်သက်၍ ကွဲလွဲနေသော ထင်မြင်ယူဆချက်များကို ကျွန်ုပ် တစ်ကြိမ်ထက်ပိုပြီး ကြားသိခဲ့ရသည် - ကြေငြာထားသော ရလဒ်များနှင့် အစစ်အမှန်ရလဒ်များကို မည်သို့ နှိုင်းယှဉ်ကြည့်ကြပါစို့။

အတိုချုံးပညာရေးအစီအစဉ် သို့မဟုတ် RNG သည် အမှန်တကယ်တွင် RNG ဖြစ်သည်။

အကယ်၍ သင်သည် ကျပန်းနံပါတ် ဂျင်နရေတာများနှင့် ရင်းနှီးပြီးသားဖြစ်ပါက "စမ်းသပ်ခြင်း" ကဏ္ဍသို့ ချက်ချင်းကျော်သွားနိုင်ပါသည်။

ကျပန်းနံပါတ်များ (RN) သည် အင်ထရိုပီ၏ အရင်းအမြစ်အချို့ကို အသုံးပြု၍ ကျပန်း (ဖရိုဖရဲ) လုပ်ငန်းစဉ်ကို အသုံးပြု၍ ထုတ်ပေးသည့် နံပါတ်များ ၏ အတွဲလိုက်တစ်ခုဖြစ်သည်။ ဆိုလိုသည်မှာ၊ ဤအရာများသည် မည်သည့်သင်္ချာဥပဒေဖြင့်မျှ အပြန်အလှန်ဆက်စပ်မှုမရှိသော အစီအစဥ်တစ်ခုဖြစ်သည် - ၎င်းတို့တွင် အကြောင်းတရားနှင့် အကျိုးသက်ရောက်မှု ဆက်စပ်မှုမရှိပါ။

ကျပန်းနံပါတ်ကို ဖန်တီးပေးသည့်အရာကို Random Number Generator (RNG) ဟုခေါ်သည်။ အရာအားလုံးသည် မူလတန်းဟုထင်ရသော်လည်း ကျွန်ုပ်တို့သည် သီအိုရီမှ လက်တွေ့သို့ ရွေ့သွားပါက၊ ယင်းကဲ့သို့ sequence ကိုဖန်တီးရန်အတွက် software algorithm တစ်ခုကို အကောင်အထည်ဖေါ်ရန်မှာ လွယ်ကူသည်မဟုတ်။

အကြောင်းရင်းမှာ ခေတ်မီလူသုံး အီလက်ထရွန်းနစ်ပစ္စည်းများတွင် ထိုကဲ့သို့ ပရမ်းပတာမရှိခြင်းကြောင့် ဖြစ်သည်။ ၎င်းမရှိဘဲ၊ ကျပန်းနံပါတ်များသည် ကျပန်းအဖြစ်မှ ရပ်စဲသွားကာ ၎င်းတို့၏ ဂျင်နရေတာသည် ထင်ရှားစွာသတ်မှတ်ထားသော အကြောင်းပြချက်များ၏ သာမန်လုပ်ဆောင်မှုတစ်ခုအဖြစ်သို့ ပြောင်းလဲသွားသည်။ IT နယ်ပယ်ရှိ အထူးပြုမှုများစွာအတွက်၊ ဤသည်မှာ လေးနက်သောပြဿနာ (ဥပမာ၊ လျှို့ဝှက်စာရိုက်ခြင်း) ဖြစ်သော်လည်း အခြားသူများအတွက် လုံးဝလက်ခံနိုင်သော အဖြေတစ်ခုရှိပါသည်။

အမှန်တကယ် ကျပန်းနံပါတ်များမဟုတ်သော်လည်း ၎င်းတို့နှင့် အနီးစပ်ဆုံး - Pseudo-random နံပါတ်များ (PRN) ဟုခေါ်သော အနီးစပ်ဆုံး ပြန်လာမည့် algorithm တစ်ခုကို ရေးသားရန် လိုအပ်ပါသည်။ ဤကိစ္စရပ်တွင် algorithm ကို pseudorandom နံပါတ်ဂျင်နရေတာ (PRNG) ဟုခေါ်သည်။

PRNG ဖန်တီးရန်အတွက် ရွေးချယ်စရာများစွာရှိသော်လည်း အောက်ပါတို့သည် လူတိုင်းအတွက် သက်ဆိုင်လိမ့်မည်-

1. ပဏာမ ကနဦးအစပြုရန် လိုအပ်သည်။

   PRNG တွင် entropy ၏အရင်းအမြစ်မရှိသောကြောင့်၎င်းကိုအသုံးမပြုမီကနဦးအခြေအနေတစ်ခုပေးရပါမည်။ ၎င်းကို နံပါတ် (သို့မဟုတ် vector) အဖြစ် သတ်မှတ်ထားပြီး မျိုးစေ့ (ကျပန်းမျိုးစေ့) ဟုခေါ်သည်။ မကြာခဏ၊ ပရိုဆက်ဆာနာရီကောင်တာ သို့မဟုတ် စနစ်အချိန်နှင့်ညီမျှသော ဂဏန်းများကို အစေ့တစ်ခုအဖြစ် အသုံးပြုသည်။

2. တစ်ဆက်တည်း မျိုးပွားနိုင်ခြင်း။

   PRNG သည် လုံးဝအဆုံးအဖြတ်ဖြစ်သည်၊ ထို့ကြောင့် ကနဦးအစတွင် သတ်မှတ်ထားသော မျိုးစေ့သည် နံပါတ်များ၏ အနာဂတ် sequence တစ်ခုလုံးကို ထူးခြားစွာ ဆုံးဖြတ်သည်။ ဆိုလိုသည်မှာ တူညီသောမျိုးစေ့ဖြင့် သီးခြား PRNG (ကွဲပြားခြားနားသောအချိန်များတွင်၊ မတူညီသောပရိုဂရမ်များတွင်၊ မတူညီသောစက်ပစ္စည်းများတွင်) တူညီသောအစီအစဥ်ကို ထုတ်ပေးမည်ဟု ဆိုလိုသည်။

PRNG ကို ဖော်ပြသည့် ဖြစ်နိုင်ခြေ ဖြန့်ဖြူးမှုကိုလည်း သိရန် လိုအပ်သည် - ၎င်းသည် မည်သည့် နံပါတ်များ ထုတ်ပေးမည် နှင့် ဖြစ်နိုင်ခြေ မည်မျှရှိမည်ကို သိရန် လိုအပ်ပါသည်။ အများစုမှာ ၎င်းသည် ပုံမှန်ဖြန့်ဖြူးမှု သို့မဟုတ် တစ်ပြေးညီ ဖြန့်ဖြူးမှုဖြစ်သည်။

ပုံမှန် ဖြန့်ဖြူးခြင်း (ဘယ်) နှင့် ယူနီဖောင်း ဖြန့်ဖြူးခြင်း (ညာ)၊

ကျွန်ုပ်တို့တွင် အဘက် 24 လုံးပါသော တရားမျှတသော သေတ္တာတစ်ခုရှိသည် ဆိုကြပါစို့။ ၎င်းကိုပစ်ပါက၊ တစ်ခုရရှိရန်ဖြစ်နိုင်ခြေသည် 1/24 နှင့် ညီမျှလိမ့်မည် (အခြားနံပါတ်တစ်ခုရနိုင်ခြေနှင့် အတူတူပင်ဖြစ်သည်)။ အကြိမ်ပေါင်းများစွာ ပစ်လိုက်ပြီး ရလဒ်များကို မှတ်တမ်းတင်ပါက၊ အစွန်းများအားလုံးသည် ခန့်မှန်းခြေအားဖြင့် တူညီသောကြိမ်နှုန်းဖြင့် ပြုတ်ကျသွားသည်ကို သတိပြုမိပါလိမ့်မည်။ အခြေခံအားဖြင့်၊ ဤအသေကို ယူနီဖောင်းဖြန့်ဖြူးမှုဖြင့် RNG ဟု ယူဆနိုင်သည်။

ဒီအန်စာတုံး ၁၀ လုံးကို တစ်ခါတည်းပစ်ပြီး စုစုပေါင်း အမှတ်တွေကို ရေတွက်ရင် ဘာဖြစ်မလဲ။ ညီညွှတ်မှုကို ထိန်းသိမ်းနိုင်ပါ့မလား။ မရှိ အများစုမှာ၊ ပမာဏသည် 10 မှတ်၊ ဆိုလိုသည်မှာ အချို့သော ပျမ်းမျှတန်ဖိုးနှင့် နီးစပ်မည်ဖြစ်သည်။ ရလဒ်အနေနှင့်၊ ပစ်မချမီတွင်ပင် အနာဂတ်ရလဒ်ကို အကြမ်းဖျင်း ခန့်မှန်းနိုင်သည်။

အကြောင်းပြချက်မှာ ပျမ်းမျှရမှတ်ကို ရယူရန် ပေါင်းစပ်အရေအတွက် အများဆုံး ပေါင်းစပ်မှုများ ရှိနေသောကြောင့် ဖြစ်သည်။ ၎င်းနှင့် ဝေးလေ၊ ပေါင်းစပ်မှု နည်းပါးလေလေ - နှင့် လျော်ညီစွာ ဆုံးရှုံးမှု ဖြစ်နိုင်ခြေ နည်းပါးလေဖြစ်သည်။ ဤဒေတာကို မြင်ယောင်မိပါက၊ ၎င်းသည် ခေါင်းလောင်းပုံသဏ္ဍာန်နှင့် ဆင်တူသည်။ ထို့ကြောင့်၊ အချို့သောအချိန်ဆွဲခြင်းဖြင့်၊ အန်စာတုံး ၁၀ ခုပါသောစနစ်ကို ပုံမှန်ဖြန့်ဖြူးမှုဖြင့် RNG ဟုခေါ်ဆိုနိုင်သည်။

နောက်ဥပမာတစ်ခုက လေယာဉ်ပေါ်မှာ ဒီတစ်ကြိမ်သာ ပစ်မှတ်ကို ပစ်တာ။ သေနတ်သမားသည် ဂရပ်ပေါ်တွင်ပြသထားသည့် နံပါတ်အတွဲ (x၊ y) ကိုထုတ်ပေးသည့် RNG ဖြစ်လိမ့်မည်။

ဘယ်ဘက်ရှိ option သည် လက်တွေ့ဘဝနှင့် ပိုမိုနီးစပ်ကြောင်း သဘောတူပါသည် - ၎င်းသည် ပုံမှန်ဖြန့်ဖြူးမှုရှိသော RNG ဖြစ်သည်။ ဒါပေမယ့် မှောင်မည်းနေတဲ့ကောင်းကင်မှာ ကြယ်တွေကို ဖြန့်ကြဲချင်တယ်ဆိုရင်တော့ RNG ကို တစ်ပြေးညီ ဖြန့်ဝေမှုနဲ့အတူ ရရှိထားတဲ့ မှန်ကန်တဲ့ရွေးချယ်မှုက ပိုသင့်တော်ပါတယ်။ ယေဘုယျအားဖြင့် လက်ထဲတွင်ရှိသော အလုပ်ပေါ်မူတည်၍ မီးစက်ကို ရွေးချယ်ပါ။

ယခု PNG အစီအစဥ်၏ entropy အကြောင်းပြောကြပါစို့။ ဥပမာအားဖြင့်၊ ဤကဲ့သို့သောအစပြုသော sequence တစ်ခုရှိသည်။

၈၉၊ ၉၃၊ ၃၃၊ ၃၂၊ ၈၂၊ ၂၁၊ ၄၊ ၄၂၊ ၁၁၊ ၈၊ ၆၀၊ ၉၅၊ ၅၃၊ ၃၀၊ ၄၂၊ ၁၉၊ ၃၄၊ ၃၅၊ ၆၂၊ ၂၃၊ ၄၄၊ ၃၈၊ ၇၄၊ ၃၆၊ ၅၂၊ ၁၈၊ ၅၈၊ ၇၉၊ ၆၅၊ ၄၅၊ ၉၉၊ ၉၀၊ ၈၂၊ ၂၀၊ ၄၁၊ ၁၃၊ ၈၈၊ ၇၆၊ ၈၂၊ ၂၄၊ ၅၊ ၅၄၊ ၇၂၊ ၁၉၊ ၈၀၊ ၂၊ ၇၄၊ ၃၆၊ ၇၁၊ ၉၊ ...

ပထမတစ်ချက်တွင် ဤနံပါတ်များသည် မည်မျှ ကျပန်းဖြစ်သနည်း။ ဖြန့်ဖြူးမှုကို စစ်ဆေးခြင်းဖြင့် စတင်ကြပါစို့။

၎င်းသည် ယူနီဖောင်းနှင့် နီးစပ်သော်လည်း ဂဏန်းနှစ်လုံး၏ အစီအစဥ်ကို ဖတ်ရှုပြီး လေယာဉ်ပေါ်တွင် သြဒိနိတ်များအဖြစ် အဓိပ္ပာယ်ပြန်ဆိုပါက ဤအရာကို သင်ရရှိမည်ဖြစ်သည်။

ပုံစံများကို ရှင်းရှင်းလင်းလင်း မြင်နိုင်လာသည်။ အစီအစဥ်ရှိ ဒေတာများကို တိကျသောနည်းဖြင့် စီစဥ်ထားသောကြောင့် (ဆိုလိုသည်မှာ ၎င်းတွင် အင်ထရိုပီနည်းသော)၊ ၎င်းသည် အလွန် "ဘက်လိုက်မှု" ကို ဖြစ်ပေါ်စေနိုင်သည်။ အနည်းဆုံးအားဖြင့်၊ ထိုကဲ့သို့သော PRNG သည် လေယာဉ်ပေါ်တွင် သြဒိနိတ်များထုတ်ပေးရန်အတွက် အလွန်သင့်လျော်မှုမရှိပါ။

နောက်တစ်မျိုး-

၈၉၊ ၉၃၊ ၃၃၊ ၃၂၊ ၈၂၊ ၂၁၊ ၄၊ ၄၂၊ ၁၁၊ ၈၊ ၆၀၊ ၉၅၊ ၅၃၊ ၃၀၊ ၄၂၊ ၁၉၊ ၃၄၊ ၃၅၊ ၆၂၊ ၂၃၊ ၄၄၊ ၃၈၊ ၇၄၊ ၃၆၊ ၅၂၊ ၁၈၊ ၅၈၊ ၇၉၊ ၆၅၊ ၄၅၊ ၉၉၊ ၉၀၊ ၈၂၊ ၂၀၊ ၄၁၊ ၁၃၊ ၈၈၊ ၇၆၊ ၈၂၊ ၂၄၊ ၅၊ ၅၄၊ ၇၂၊ ၁၉၊ ၈၀၊ ၂၊ ၇၄၊ ၃၆၊ ၇၁၊ ၉၊ ...

လေယာဉ်ပေါ်မှာတောင် ဒီမှာ အားလုံးအဆင်ပြေနေပုံရတယ်။

အသံအတိုးအကျယ်ကို ကြည့်ရအောင် (တစ်ကြိမ်လျှင် ဂဏန်းသုံးလုံးဖတ်ပါ)။

နောက်တဖန် ပုံစံများ။ လေးဖက်မြင်ပုံဖော်မှုကို တည်ဆောက်ရန် မဖြစ်နိုင်တော့ပါ။ သို့သော် ပုံစံများသည် ဤအတိုင်းအတာနှင့် ပိုကြီးသောပုံများတွင် ရှိနေနိုင်သည်။

PRNG များပေါ်တွင် အပြင်းထန်ဆုံး လိုအပ်ချက်များကို သတ်မှတ်သည့် cryptography တွင်၊ ထိုသို့သော အခြေအနေသည် လုံးဝလက်မခံနိုင်ပါ။ ထို့ကြောင့်၊ ကျွန်ုပ်တို့သည် ယခုအချိန်တွင် မထိတော့ဘဲ ၎င်းတို့၏ အရည်အသွေးကို အကဲဖြတ်ရန် အထူး algorithms များကို တီထွင်ထားပါသည်။ ခေါင်းစဉ်က ကျယ်ပြောပြီး သီးခြားဆောင်းပါးနဲ့ ထိုက်တန်ပါတယ်။

စမ်းသပ်ခြင်း

တစ်ခုခုကို သေချာမသိရင် အဲဒါကို ဘယ်လိုလုပ်ဆောင်မလဲ။ ဘယ်မီးပွိုင့်က ခွင့်ပြုထားလဲ မသိရင် လမ်းဖြတ်ကူးရတာ တန်သလား။ အကျိုးဆက်များ ကွဲပြားနိုင်သည်။

Unity တွင် နာမည်ဆိုးဖြင့် ကျော်ကြားသော ကြုံရာကျပန်းခြင်းအတွက် အလားတူပင်ဖြစ်သည်။ စာရွက်စာတမ်းသည် လိုအပ်သောအသေးစိတ်အချက်အလက်များကို ဖော်ပြပါက ကောင်းမွန်သော်လည်း ဆောင်းပါးအစတွင် ဖော်ပြထားသော ဇာတ်လမ်းသည် လိုချင်သော အသေးစိတ်အချက်များ မရှိခြင်းကြောင့် အတိအကျ ဖြစ်သွားပါသည်။

ကိရိယာ၏ အလုပ်လုပ်ပုံကို သင်မသိပါက၊ ၎င်းကို မှန်ကန်စွာ အသုံးပြုနိုင်မည် မဟုတ်ပါ။ ယေဘုယျအားဖြင့်၊ ဖြန့်ဖြူးမှုနှင့်ပတ်သက်၍ အနည်းဆုံးသေချာစေရန် နောက်ဆုံးတွင် စစ်ဆေးပြီး စမ်းသပ်မှုတစ်ခုလုပ်ဆောင်ရန် အချိန်ကျရောက်လာပြီဖြစ်သည်။

ဖြေရှင်းချက်သည် ရိုးရှင်းပြီး ထိရောက်သည် - စာရင်းဇယားများကို စုဆောင်းပါ၊ ရည်မှန်းချက်ဒေတာရယူပြီး ရလဒ်များကို ကြည့်ရှုပါ။

ဘာသာရပ်

Unity တွင် ကျပန်းနံပါတ်များထုတ်လုပ်ရန် နည်းလမ်းများစွာရှိသည် - ကျွန်ုပ်တို့ငါးခုကို စမ်းသပ်ခဲ့သည်။

1. System.Random.Next()။ ပေးထားသောတန်ဖိုးများအကွာအဝေးတွင် ကိန်းပြည့်များကိုထုတ်ပေးသည်။
2. System.Random.NextDouble()။ [0; ၁)။
3. UnityEngine.Random.Range()။ ပေးထားသောတန်ဖိုးများအကွာအဝေးတွင် တိကျသောနံပါတ်များ (floats) တစ်ခုတည်းကိုထုတ်ပေးသည်။
4. UnityEngine.Random.value။ [0; ၁)။
5. Unity.Mathematics.Random.NextFloat(). Unity.Mathematics စာကြည့်တိုက်အသစ်၏ တစ်စိတ်တစ်ပိုင်း။ ပေးထားသောတန်ဖိုးများအကွာအဝေးတွင် တိကျသောနံပါတ်များ (floats) တစ်ခုတည်းကိုထုတ်ပေးသည်။

UnityEngine.Random.value မှလွဲ၍ အခြားစာရွက်စာတမ်းများတွင် နေရာတိုင်းလိုလိုတွင် တူညီသောဖြန့်ဝေမှုကို သတ်မှတ်ထားသည် (ဖြန့်ဖြူးမှုကို မသတ်မှတ်ထားသော်လည်း UnityEngine.Random.Range() နှင့် တူညီသော တူညီမှုဖြင့် မျှော်မှန်းထားသည်) နှင့် Unity.Mathematics.Random .NextFloat() (အခြေခံတွင် xorshift algorithm ဖြစ်သည်၊ ဆိုလိုသည်မှာ သင်သည် ယူနီဖောင်းဖြန့်ဖြူးမှုတစ်ခုအတွက် ထပ်မံစောင့်ဆိုင်းရန် လိုအပ်သည်ဟု ဆိုလိုသည်)။

ပုံမှန်အားဖြင့်၊ မျှော်လင့်ထားသည့်ရလဒ်များကို စာရွက်စာတမ်းတွင် သတ်မှတ်ထားသည့်အတိုင်း ပြုလုပ်ထားသည်။

စက်မှုပညာ

တင်ပြနည်းလမ်းတစ်ခုစီကို အသုံးပြု၍ ကျပန်းနံပါတ်များကို ဆက်တိုက်ထုတ်ပေးသည့် အပလီကေးရှင်းငယ်တစ်ခုကို ကျွန်ုပ်တို့ရေးသားခဲ့ပြီး ရလဒ်များကို ဆက်လက်လုပ်ဆောင်ရန်အတွက် သိမ်းဆည်းထားသည်။

အစီအစဥ်တစ်ခုစီ၏ အရှည်သည် နံပါတ် 100 ဖြစ်သည်။
ကျပန်းနံပါတ်များ၏ အကွာအဝေးမှာ [0, 100) ဖြစ်သည်။

ဒေတာများကို ပစ်မှတ်ပလက်ဖောင်းအများအပြားမှ စုဆောင်းခဲ့သည်-

• Windows ကို
  — Unity v2018.3.14f1၊ တည်းဖြတ်မုဒ်၊ Mono၊ .NET Standard 2.0
• MacOS
  — Unity v2018.3.14f1၊ တည်းဖြတ်မုဒ်၊ Mono၊ .NET Standard 2.0
  — Unity v5.6.4p4၊ တည်းဖြတ်မုဒ်၊ Mono၊ .NET Standard 2.0
• အန်းဒရွိုက်
  — Unity v2018.3.14f1၊ စက်တစ်ခုစီတည်ဆောက်မှု၊ Mono၊ .NET Standard 2.0
• iOS ကို
  — Unity v2018.3.14f1၊ စက်တစ်ခုစီတည်ဆောက်မှု၊ il2cpp၊ .NET Standard 2.0

အကောင်အထည်ဖော်မှု

ကျပန်းနံပါတ်များထုတ်လုပ်ရန် ကျွန်ုပ်တို့တွင် မတူညီသောနည်းလမ်းများစွာရှိသည်။ ၎င်းတို့တစ်ခုစီအတွက်၊ ပံ့ပိုးပေးသင့်သည့် သီးခြား wrapper class ကို ရေးပါမည်။

1. တန်ဖိုးများ [min/max) အကွာအဝေးကို သတ်မှတ်ရန် ဖြစ်နိုင်ခြေရှိသည်။ constructor မှ တစ်ဆင့် သတ်မှတ်မည်ဖြစ်သည်။
2. MF ကို ပြန်ပေးသည့်နည်းလမ်း။ ပိုပြီး ယေဘုယျ အားဖြင့် float ကို အမျိုးအစားအဖြစ် ရွေးကြပါစို့။
3. ရလဒ်များကို အမှတ်အသားပြုလုပ်ရန် မျိုးဆက်နည်းလမ်းအမည်။ အဆင်ပြေစေရန်၊ အတန်း၏အမည်အပြည့်အစုံ + MF ကိုထုတ်လုပ်ရန်အသုံးပြုသည့်နည်းလမ်းအမည်ကို တန်ဖိုးအဖြစ် ကျွန်ုပ်တို့ပြန်ပေးပါမည်။

ဦးစွာ၊ IRandomGenerator interface ဖြင့်ကိုယ်စားပြုမည့် abstraction တစ်ခုကိုကြေငြာကြပါစို့။

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

        float Generate();
    }
}

System.Random.Next() ကို အကောင်အထည်ဖော်ခြင်း

ဤနည်းလမ်းသည် သင့်အား တန်ဖိုးများအကွာအဝေးကို သတ်မှတ်ခွင့်ပြုသော်လည်း ၎င်းသည် ကိန်းပြည့်များကို ပြန်ပေးသော်လည်း float များကို လိုအပ်ပါသည်။ ကိန်းပြည့်ကို float အဖြစ် ရိုးရိုးရှင်းရှင်း အဓိပ္ပာယ်ဖွင့်ဆိုနိုင်သည်၊ သို့မဟုတ် အတိုင်းအတာ၏ အတိုင်းအတာများစွာဖြင့် တန်ဖိုးများကို ချဲ့ထွင်နိုင်ပြီး ၎င်းတို့ကို အလယ်အလတ်တန်းစား မျိုးဆက်တစ်ခုစီနှင့် လျော်ကြေးပေးနိုင်သည်။ ရလဒ်သည် တိကျသောအစီအစဥ်ဖြင့် ပုံသေအမှတ်ကဲ့သို့ တစ်ခုခုဖြစ်လိမ့်မည်။ အစစ်အမှန် 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; ၁)။ ၎င်းကို constructor တွင်သတ်မှတ်ထားသည့်တစ်ခုပေါ်တွင် ပရောဂျက်လုပ်ရန်၊ ကျွန်ုပ်တို့သည် ရိုးရှင်းသောဂဏန်းသင်္ချာကိုအသုံးပြုသည်- 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 static class ၏ ဤနည်းလမ်းသည် သင့်အား တန်ဖိုးများကို အကွာအဝေးတစ်ခုသတ်မှတ်ပြီး float အမျိုးအစားကို ပြန်ပေးနိုင်သည်။ နောက်ထပ် ပြောင်းလဲမှုများ ပြုလုပ်ရန် မလိုအပ်ပါ။

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; ၁)။ 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() method သည် float အမျိုးအစား၏ floating point ကို return လုပ်ပြီး values ​​အပိုင်းအခြားကို သတ်မှတ်နိုင်စေပါသည်။ တစ်ခုတည်းသော ကွဲပြားချက်မှာ Unity.Mathematics.Random ၏ ဥပမာတစ်ခုစီကို မျိုးစေ့အချို့ဖြင့် အစပြုရမည်ဖြစ်ပြီး၊ ဤနည်းဖြင့် ထပ်ခါတလဲလဲ sequence များကို ထုတ်ပေးခြင်းကို ရှောင်ကြဉ်ပါမည်။

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 ၏အကောင်အထည်ဖော်မှုအများအပြားအဆင်သင့်ဖြစ်နေပါပြီ။ ထို့နောက်၊ သင်လုပ်ဆောင်ရန်အတွက် sequences များဖန်တီးရန်နှင့် ရရှိလာသော dataset ကို သိမ်းဆည်းရန်လိုအပ်သည်။ ၎င်းကိုလုပ်ဆောင်ရန်၊ ကျွန်ုပ်တို့သည် Unity တွင် မြင်ကွင်းတစ်ခုနှင့် MainController script အသေးတစ်ခုကို ဖန်တီးမည်ဖြစ်ပြီး၊ လိုအပ်သည့်အလုပ်အားလုံးကို လုပ်ဆောင်မည်ဖြစ်ပြီး 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)
            };
        }

        ...
    }
}

အခု dataset တစ်ခုဖန်တီးကြည့်ရအောင်။ ဤကိစ္စတွင်၊ ဒေတာထုတ်လုပ်ခြင်းသည် ရလဒ်များကို စာသားစီးကြောင်း (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 ၏ပုံမှန်ဖြန့်ဖြူးမှုနှင့်ပတ်သက်ပြီး နိဒါန်းတွင်ဖော်ပြထားသော ဇာတ်လမ်းသည် သူ့ဘာသာသူ ထပ်ခါတလဲလဲ မဖြစ်ခဲ့ပါ- ၎င်းသည် အစပိုင်းတွင် မှားယွင်းနေသည် သို့မဟုတ် အင်ဂျင်အတွင်း တစ်ခုခု ပြောင်းလဲသွားခဲ့သည်။ ဒါပေမယ့် အခုတော့ သေချာသွားပြီ။

source: www.habr.com