वेक्टर फंक्शन में

वेक्टर फंक्शन के बारे में

R में यह एक बड़ा कॉन्सेप्ट है। इन संभावनाओं को समझने में यह बात मदद करती है कि हम देखें कि अलग-अलग फंक्शन के इनपुट और आउटपुट कितने आयाम के होते हैं।

वेक्टर इनपुट, स्केलर आउटपुट

हम पहले ही ऐसे फंक्शन देख चुके हैं जो एक वेक्टर लेते हैं और एक ही स्केलर जैसी वैल्यू लौटाते हैं:

v <- 1:5
length(v)
#> [1] 5
sum(v)
#> [1] 15

बहुत से सांख्यिकीय फंक्शन भी इसी श्रेणी में आते हैं, जैसे mean()।

लॉजिकल वेक्टर के लिए all() और any() हैं, जो एक ही TRUE या FALSE लौटाते हैं।

वेक्टर इनपुट, वेक्टर आउटपुट

R में बहुत से फंक्शन पूरे वेक्टर पर काम करते हैं और अक्सर वेक्टर ही आउटपुट देते हैं। इसमें ज़्यादातर गणितीय फंक्शन आते हैं:

sq <- c(4, 9, 16, 25)
sqrt(sq) # square root
#> [1] 2 3 4 5

यह सिर्फ छोटा और सुविधाजनक ही नहीं है, बल्कि इससे लूप, लिस्ट कॉम्प्रिहेंशन या रिकर्सन की ज़रूरत ही नहीं पड़ती, जो दूसरी भाषाओं में आम हैं। R में वेक्टर फंक्शन अक्सर उन तरीकों से कहीं तेज़ चलते हैं।

आपने शायद सोचा भी न हो, लेकिन वेक्टराइज़्ड फंक्शन आप पहले भी कई बार इस्तेमाल कर चुके हैं। इनकी तुलना कीजिए:

v <- c(2, 7, 9)
w <- c(3, 1, 5)
v + w
#> [1]  5  8 14
"+"(v, w)
#> [1]  5  8 14

ये परिचित इन्फिक्स ऑपरेटर असल में उस वेक्टराइज़्ड फंक्शन के लिए सिर्फ सिंटैक्टिक शुगर हैं जो पीछे काम करता है! यहाँ वह फंक्शन "+"() है।

किसी वेक्टर को क्रम में लगाने के लिए sort() है, जो वैल्यू लौटाता है, और order() है, जो इंडेक्स लौटाता है:

v <- c("I", "am", "not", "in", "order")
sort(v)
#> [1] "am"    "I"     "in"    "not"   "order"
order(v)
#> [1] 2 1 4 3 5

डिफाल्ट रूप से क्रम बढ़ते क्रम में लगाया जाता है। ज़रूरत हो तो decreasing = TRUE दीजिए, या किसी मौजूदा वेक्टर को उलटने के लिए rev() इस्तेमाल कीजिए।

v <- c("I", "am", "not", "in", "order")
sort(v, decreasing = TRUE)
#> [1] "order" "not"   "in"    "I"     "am"

rev(1:4)
#> [1] 4 3 2 1

ऐसे फंक्शन भी हैं जैसे cumsum() और cumprod(), जो संचयी वेक्टर आउटपुट बनाते हैं और इनपुट वेक्टर पर बाएँ से दाएँ काम करते हैं:

cumsum(1:5)
#> [1]  1  3  6 10 15  # sums
cumprod(1:5)
#> [1]   1   2   6  24 120 # equivalent to factorials

ऊपर के उदाहरण बहुत सी फंक्शनल भाषाओं में foldl जैसे काम से मिलते-जुलते हैं, फर्क बस इतना है कि यहाँ आउटपुट एक वेक्टर होता है जिसमें बीच की सारी वैल्यू भी शामिल रहती हैं।

कई वेक्टर इनपुट, वेक्टर आउटपुट

इसी कॉन्सेप्ट का विस्तार करके वेक्टर की तुलना भी की जा सकती है। उदाहरण के लिए, जोड़ी के हिसाब से अधिकतम निकालने वाला फंक्शन pmax() देखिए:

v
#> [1] 2 7 9
w
#> [1] 3 1 5
pmax(v, w)
#> [1] 3 7 9 # max of each pairwise comparison

यह फंक्शन और इस जैसे दूसरे फंक्शन सिर्फ दो ही नहीं, कितने भी इनपुट वेक्टर ले सकते हैं।

ऊपर के उदाहरण में दोनों वेक्टर की लंबाई बराबर है। जैसा कि वेक्टर फिल्टरिंग कॉन्सेप्ट में बताया गया है, R उन वेक्टर को बढ़ाने के लिए रीसाइक्लिंग करता है जो किसी वजह से "बहुत छोटे" रह गए हों। दोहरा दें: इसे सावधानी से इस्तेमाल कीजिए, और बेहतर होगा कि सिर्फ लंबाई-1 वाले वेक्टर के साथ करें।

pmax(v, 5)
#> [1] 5 7 9

वेक्टर इनपुट, मैट्रिक्स आउटपुट

यह कम आम है, पर ऐसे फंक्शन लिखना काफी आसान है जो देखने में स्केलर इनपुट लेते लगें और वेक्टर आउटपुट दें। जब इन्हें वेक्टर इनपुट दिया जाता है, तो आउटपुट एक दो-आयामी matrix होता है (इसे आगे के कॉन्सेप्ट में समझाया गया है)।