R လုပ်ဆောင်ချက်များ
လုပ်ဆောင်ချက်တစ်ခုသည် ၎င်းကို ခေါ်သည့်အခါတွင်သာ လုပ်ဆောင်သည့် ကုဒ်တစ်ခုဖြစ်သည်။
ဒေတာများကို ဘောင်များဟုသိကြသော လုပ်ဆောင်ချက်တစ်ခုသို့ သင်ဖြတ်သန်းနိုင်သည်။
လုပ်ဆောင်ချက်တစ်ခုသည် ရလဒ်အဖြစ် ဒေတာကို ပြန်ပေးနိုင်သည်။
Function တစ်ခုဖန်တီးခြင်း။
လုပ်ဆောင်ချက်တစ်ခုဖန်တီးရန် function()သော့ချက်စကားလုံးကို အသုံးပြုပါ-
ဥပမာ
my_function <- function() { # create a function with the name my_function
print("Hello World!")
}
Function ကိုခေါ်ပါ။
လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ရန်၊ my_function() ကဲ့သို့သော ကွင်းစဥ်နောက်တွင်ရှိသော လုပ်ဆောင်ချက်အမည်ကို အသုံးပြုပါ ။
ဥပမာ
my_function <- function() {
print("Hello World!")
}
my_function() # call the function named my_function
အငြင်းပွားမှုများ
အချက်အလက်များကို အကြောင်းပြချက်များအဖြစ် လုပ်ငန်းဆောင်တာများသို့ လွှဲပြောင်းပေးနိုင်သည်။
ကွင်းစဥ်များအတွင်း၊ လုပ်ဆောင်ချက်အမည်ပြီးနောက် အကြောင်းပြချက်များကို သတ်မှတ်ပေးသည်။ အကြောင်းပြချက်များစွာကို သင်အလိုရှိသလောက်ထည့်နိုင်ပြီး ၎င်းတို့ကို ကော်မာတစ်ခုဖြင့် ခွဲရုံသာဖြစ်သည်။
အောက်ပါဥပမာတွင် အငြင်းအခုံတစ်ခု (fname) ဖြင့် လုပ်ဆောင်ချက်တစ်ခုရှိသည်။ လုပ်ဆောင်ချက်ကို ခေါ်သောအခါ၊ အမည်အပြည့်အစုံကို ပရင့်ထုတ်ရန် လုပ်ဆောင်ချက်အတွင်းတွင် အသုံးပြုသည့် ပထမအမည်တစ်ခုကို ကျွန်ုပ်တို့ ဖြတ်သွားသည်-
ဥပမာ
my_function <- function(fname) {
paste(fname, "Griffin")
}
my_function("Peter")
my_function("Lois")
my_function("Stewie")
ကန့်သတ်ချက်များ သို့မဟုတ် အကြောင်းပြချက်များ
"ပါရာမီတာ" နှင့် "အငြင်းပွားမှု" ဟူသော ဝေါဟာရများသည် တူညီသောအရာအတွက် အသုံးပြုနိုင်သည်။
လုပ်ဆောင်ချက်တစ်ခု၏ရှုထောင့်မှ
ဘောင်တစ်ခုသည် လုပ်ဆောင်ချက်အဓိပ္ပါယ်ဖွင့်ဆိုချက်ရှိ ကွင်းအတွင်း၌ဖော်ပြထားသော ကိန်းရှင်ဖြစ်သည်။
အငြင်းအခုံတစ်ခုသည် ၎င်းကိုခေါ်သောအခါတွင် လုပ်ဆောင်ချက်ထံသို့ ပေးပို့သည့်တန်ဖိုးဖြစ်သည်။
အငြင်းအခုံအရေအတွက်
ပုံမှန်အားဖြင့်၊ မှန်ကန်သော အကြောင်းပြချက်အရေအတွက်ဖြင့် လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ရပါမည်။ ဆိုလိုသည်မှာ သင့် function သည် အငြင်းအခုံ 2 ခုကို မျှော်လင့်ပါက၊ သင်သည် function ကို argument 2 ခုဖြင့် ခေါ်ရမည်၊ မပို၊ မနည်းပါ
ဥပမာ
ဤလုပ်ဆောင်ချက်သည် အကြောင်းပြချက် 2 ခုကို မျှော်လင့်ထားပြီး အကြောင်းပြချက် 2 ခုကို ရရှိသည်-
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter", "Griffin")
အကယ်၍ သင်သည် အကြောင်းပြချက် 1 သို့မဟုတ် 3 ဖြင့် လုပ်ဆောင်ချက်ကို ခေါ်ရန်ကြိုးစားပါက၊ သင်သည် error တစ်ခုရလိမ့်မည်-
ဥပမာ
ဤလုပ်ဆောင်ချက်သည် အကြောင်းပြချက် 2 ခုကို မျှော်လင့်ထားပြီး အကြောင်းပြချက် 1 ခု ရရှိသည်-
my_function <- function(fname, lname) {
paste(fname, lname)
}
my_function("Peter")
မူရင်း ကန့်သတ်တန်ဖိုး
အောက်ဖော်ပြပါ ဥပမာသည် ပုံသေပါရာမီတာတန်ဖိုးကို မည်သို့အသုံးပြုရမည်ကို ပြသထားသည်။
အငြင်းအခုံမရှိဘဲ လုပ်ဆောင်ချက်ကို ကျွန်ုပ်တို့ခေါ်ဆိုပါက၊ ၎င်းသည် မူရင်းတန်ဖိုးကို အသုံးပြုသည်-
ဥပမာ
my_function <- function(country = "Norway") {
paste("I am
from", country)
}
my_function("Sweden")
my_function("India")
my_function()
# will get the default value, which is Norway
my_function("USA")
တန်ဖိုးများ ပြန်ပေးသည်။
လုပ်ဆောင်ချက်တစ်ခုမှ ရလဒ်တစ်ခုပြန်ရစေရန်၊ return()လုပ်ဆောင်ချက်ကို အသုံးပြုပါ-
ဥပမာ
my_function <- function(x) {
return (5 * x)
}
print(my_function(3))
print(my_function(5))
print(my_function(9))
အထက်ဖော်ပြပါ ကုဒ်၏ အထွက်သည်-
[1] 15
[1] 25
[1] 45
Nested လုပ်ဆောင်ချက်များ
nested လုပ်ဆောင်ချက်ကို ဖန်တီးရန် နည်းလမ်းနှစ်ခုရှိသည်။
- အခြားလုပ်ဆောင်ချက်တစ်ခုအတွင်း လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ပါ။
- function တစ်ခုအတွင်း function တစ်ခုရေးပါ။
ဥပမာ
အခြားလုပ်ဆောင်ချက်တစ်ခုအတွင်း လုပ်ဆောင်ချက်တစ်ခုကို ခေါ်ဆိုပါ-
Nested_function <- function(x, y) {
a <- x + y
return(a)
}
Nested_function(Nested_function(2,2), Nested_function(3,3))
နမူနာရှင်းပြထားပါတယ်။
Function က x ကို y ထည့်ဖို့ ပြောတယ်။
ပထမဆုံး ထည့်သွင်းသည့် Nested_function(2,2) သည် ပင်မလုပ်ဆောင်ချက်၏ "x" ဖြစ်သည်။
ဒုတိယထည့်သွင်းမှုသည် Nested_function(3,3) သည် ပင်မလုပ်ဆောင်ချက်၏ "y" ဖြစ်သည်။
အထွက်သည် (၂+၂)+(၃+၃)= ၁၀ ဖြစ်သည်။
ဥပမာ
လုပ်ဆောင်ချက်တစ်ခုအတွင်း လုပ်ဆောင်ချက်တစ်ခုကို ရေးပါ-
Outer_func <- function(x) {
Inner_func <- function(y) {
a <- x + y
return(a)
}
return
(Inner_func)
}
output <- Outer_func(3) # To
call the Outer_func
output(5)
နမူနာရှင်းပြထားပါတယ်။
Outer_func အတွင်းတွင် Inner_func (nested) ကို သတ်မှတ်ပြီးဖြစ်သောကြောင့် သင်သည် လုပ်ဆောင်ချက်ကို တိုက်ရိုက်ခေါ်ဆို၍မရပါ။
Inner_func ကို ဒုတိယအဆင့်အဖြစ်ခေါ်ဆိုရန်အတွက် Outer_func ကို ဦးစွာခေါ်ဆိုရန် လိုအပ်ပါသည်။
output ဟုခေါ်သော variable အသစ်တစ်ခုကို ဖန်တီးပြီး ၎င်းကို ဤနေရာတွင် 3 ဖြစ်သည့် တန်ဖိုးတစ်ခုပေးရန်လိုအပ်သည်။
ထို့နောက် လိုချင်သောတန်ဖိုး "y" ဖြင့် အထွက်ကို ပရင့်ထုတ်ပါ။
အထွက်သည် ၈ (၃+၅) ဖြစ်သည်။
ပြန်လှည့်ခြင်း။
R သည် function recursion ကို လက်ခံသည်၊ ဆိုလိုသည်မှာ သတ်မှတ်ထားသော function သည် သူ့ဘာသာသူ ခေါ်နိုင်သည်။
Recursion သည် သာမန်သင်္ချာနှင့် ပရိုဂရမ်းမင်းအယူအဆတစ်ခုဖြစ်သည်။ ဆိုလိုသည်မှာ function တစ်ခုသည် သူ့အလိုလိုခေါ်သည်။ ၎င်းသည် ရလဒ်တစ်ခုရရှိရန် အချက်အလက်များကို လှည့်ပတ်ကြည့်ရှုနိုင်သည့် အဓိပ္ပာယ်ရှိသည်။
ဆော့ဖ်ဝဲရေးသားသူသည် အဆုံးမသတ်နိုင်သော လုပ်ဆောင်ချက် သို့မဟုတ် မန်မိုရီ သို့မဟုတ် ပရိုဆက်ဆာပါဝါကို ပိုလျှံသောပမာဏကို အသုံးပြုသည့် လုပ်ဆောင်ချက်ကို ရေးသားရာတွင် အလွန်လွယ်ကူသောကြောင့် ဆော့ဖ်ဝဲရေးသားသူသည် ပြန်လှည့်ခြင်းနှင့်ပတ်သက်၍ အလွန်သတိထားသင့်သည်။ သို့သော်၊ မှန်ကန်စွာရေးသားသည့်အခါ၊ ပြန်ကောက်ချက်သည် ပရိုဂရမ်ရေးဆွဲခြင်းအတွက် အလွန်ထိရောက်ပြီး သင်္ချာနည်းအရ အံဝင်ခွင်ကျဖြစ်နိုင်ပါသည်။
ဤဥပမာတွင်၊ tri_recursion()၎င်းသည် ကျွန်ုပ်တို့ကိုယ်တိုင် ("recurse") ဟုခေါ်ဆိုရန်သတ်မှတ်ထားသောလုပ်ဆောင်ချက်တစ်ခုဖြစ်သည်။ ကျွန်ုပ်တို့ ပြန်သုံးသည့်အခါတိုင်း k( ) ကို လျှော့ချပေးသော ကိန်းရှင်ကို ဒေတာအဖြစ် အသုံးပြု
ပါသည်။ -1အခြေအနေသည် 0 ထက်မပိုသောအခါ (ဆိုလိုသည်မှာ 0 ဖြစ်သောအခါ) အဆုံးသတ်သည်။
ဆော့ဖ်ဝဲရေးသားသူအသစ်အတွက် ၎င်းမည်ကဲ့သို့အလုပ်လုပ်သည်ကို အတိအကျသိရှိရန် အချိန်အနည်းငယ်ကြာနိုင်ပြီး၊ ၎င်းကို စမ်းသပ်ခြင်းနှင့် ပြုပြင်မွမ်းမံခြင်းဖြင့် သိရှိရန် အကောင်းဆုံးနည်းလမ်းဖြစ်သည်။
ဥပမာ
tri_recursion <- function(k) {
if (k > 0) {
result <- k + tri_recursion(k - 1)
print(result)
} else {
result = 0
return(result)
}
}
tri_recursion(6)