मैं यह समझने की कोशिश कर रहा हूं कि order()फ़ंक्शन कैसे काम करता है। मैं इस धारणा के अधीन था कि इसने सूचकांकों के क्रमपरिवर्तन को लौटा दिया, जो कि जब छांटे जाते हैं, तो मूल वेक्टर को क्रमबद्ध करेंगे।
उदाहरण के लिए,
> a <- c(45,50,10,96)
> order(a)
[1] 3 1 2 4
मुझे उम्मीद थी कि यह वापसी होगी c(2, 3, 1, 4), क्योंकि छांटी गई सूची 10 45 50 96 होगी।
क्या कोई मुझे इस फ़ंक्शन के रिटर्न मूल्य को समझने में मदद कर सकता है?
जवाबों:
इससे इसकी व्याख्या प्रतीत होती है।
इसकी परिभाषा
orderयह है किa[order(a)]बढ़ते क्रम में है। यह आपके उदाहरण के साथ काम करता है, जहां सही क्रम चौथा, दूसरा, पहला, फिर तीसरा तत्व है।आप खोज रहे होंगे
rank, जो तत्वों की रैंक लौटाता है
R> a <- c(4.1, 3.2, 6.1, 3.1)
R> order(a)
[1] 4 2 1 3
R> rank(a)
[1] 3 2 4 1
ताकिrankआपको पता चल सके कि संख्याएँ किस क्रम में हैं,orderआपको बताता है कि उन्हें आरोही क्रम में कैसे प्राप्त किया जाए।
plot(a, rank(a)/length(a))सीडीएफ का ग्राफ देगा। यह देखने के लिए किorderउपयोगी क्यों है, हालांकि, कोशिश करेंplot(a, rank(a)/length(a),type="S")जो गड़बड़ करता है, क्योंकि डेटा बढ़ते क्रम में नहीं हैंयदि आपने किया
oo<-order(a)
plot(a[oo],rank(a[oo])/length(a),type="S")
या बस
oo<-order(a)
plot(a[oo],(1:length(a))/length(a)),type="S")
आपको सीडीएफ का एक रेखाचित्र मिला।
मैं शर्त लगा सकता हूँ कि आप रैंक के बारे में सोच रहे हैं।
order(a, decreasing = T)और rank(a)एक बराबर उत्तर लौटाएगा।
a<-c(4,2,1,80,13)तब order(a)होना चाहिए 3 4 5 1 2, लेकिन अजीब तरह से मुझे हो रहा है3 2 1 5 4
rankऔर orderएक ही है?
order(order(a))उसी तरह वापस आ जाएगा जैसे rank(a) कि कोई संबंध नहीं हैं। अगर वहाँ हैं तो यह उसी तरह लौटेगा rank(a, ties.method="first")।
1D वेक्टर या डेटा के एकल कॉलम को सॉर्ट करने के लिए, बस सॉर्ट फ़ंक्शन को कॉल करें और अपने अनुक्रम में पास करें।
दूसरी ओर, ऑर्डर फ़ंक्शन डेटा को दो -आयामी डेटा को सॉर्ट करने के लिए आवश्यक है - अर्थात, मैट्रिक्स या डेटाफ़्रेम में एकत्रित डेटा के कई कॉलम।
Stadium Home Week Qtr Away Off Def Result Kicker Dist
751 Out PHI 14 4 NYG PHI NYG Good D.Akers 50
491 Out KC 9 1 OAK OAK KC Good S.Janikowski 32
702 Out OAK 15 4 CLE CLE OAK Good P.Dawson 37
571 Out NE 1 2 OAK OAK NE Missed S.Janikowski 43
654 Out NYG 11 2 PHI NYG PHI Good J.Feely 26
307 Out DEN 14 2 BAL DEN BAL Good J.Elam 48
492 Out KC 13 3 DEN KC DEN Good L.Tynes 34
691 Out NYJ 17 3 BUF NYJ BUF Good M.Nugent 25
164 Out CHI 13 2 GB CHI GB Good R.Gould 25
80 Out BAL 1 2 IND IND BAL Good M.Vanderjagt 20
यहाँ 2008 एनएफएल सीज़न में फ़ील्ड लक्ष्य प्रयासों के लिए डेटा का एक अंश है, एक डेटाफ़्रेम जिसे मैंने 'fg' कहा है। मान लें कि ये 10 डेटा पॉइंट 2008 में किए गए सभी क्षेत्र लक्ष्यों का प्रतिनिधित्व करते हैं; आगे मान लें कि आप उस वर्ष के सबसे लंबे क्षेत्र के लक्ष्य की दूरी जानना चाहते हैं, जिसने इसे लात मारी, और यह अच्छा था या नहीं; आप दूसरे-सबसे लंबे, साथ ही तीसरे-सबसे लंबे, आदि को जानना चाहते हैं; और अंत में आप सबसे छोटा क्षेत्र लक्ष्य प्रयास करना चाहते हैं।
ठीक है, आप ऐसा कर सकते हैं:
sort(fg$Dist, decreasing=T)
जो रिटर्न: 50 48 43 37 34 32 26 25 25 20
यह सही है, लेकिन बहुत उपयोगी नहीं है - यह हमें सबसे लंबे क्षेत्र के लक्ष्य के प्रयास की दूरी बताता है, दूसरे-सबसे लंबे समय तक, ... साथ ही सबसे छोटा; हालाँकि, लेकिन हम सभी जानते हैं - उदाहरण के लिए, हम नहीं जानते कि किकर कौन था, क्या प्रयास सफल रहा था, आदि, बेशक, हमें "डिस्ट" कॉलम पर सॉर्ट किए गए संपूर्ण डेटाफ़्रेम की आवश्यकता है (एक और तरीका डालें, हम एकल विशेषता Dist पर सभी डेटा पंक्तियों को क्रमबद्ध करना चाहते हैं । यह इस तरह दिखेगा:
Stadium Home Week Qtr Away Off Def Result Kicker Dist
751 Out PHI 14 4 NYG PHI NYG Good D.Akers 50
307 Out DEN 14 2 BAL DEN BAL Good J.Elam 48
571 Out NE 1 2 OAK OAK NE Missed S.Janikowski 43
702 Out OAK 15 4 CLE CLE OAK Good P.Dawson 37
492 Out KC 13 3 DEN KC DEN Good L.Tynes 34
491 Out KC 9 1 OAK OAK KC Good S.Janikowski 32
654 Out NYG 11 2 PHI NYG PHI Good J.Feely 26
691 Out NYJ 17 3 BUF NYJ BUF Good M.Nugent 25
164 Out CHI 13 2 GB CHI GB Good R.Gould 25
80 Out BAL 1 2 IND IND BAL Good M.Vanderjagt 20
यही क्रम चलता है। यह दो-आयामी डेटा के लिए 'सॉर्ट' है; दूसरा तरीका रखो, यह 1D पूर्णांक इंडेक्स देता है जिसमें पंक्ति संख्याएं शामिल होती हैं जो कि उस वेक्टर के अनुसार पंक्तियों को छांटती हैं, आपको कॉलम पर एक सही पंक्ति-उन्मुख प्रकार देगा, Dist
यहां देखिए यह कैसे काम करता है। ऊपर, सॉर्ट का उपयोग डिस्ट कॉलम को सॉर्ट करने के लिए किया गया था; Dist कॉलम पर संपूर्ण डेटाफ़्रेम को सॉर्ट करने के लिए, हम 'ऑर्डर' का ठीक उसी तरह उपयोग करते हैं, जैसे 'सॉर्ट' ऊपर प्रयोग किया जाता है :
ndx = order(fg$Dist, decreasing=T)
(मैं आमतौर पर 'ऑर्डर' से लौटे हुए सरणी को वेरिएबल 'ndx' में बाँधता हूँ, जो 'इंडेक्स' के लिए है, क्योंकि मैं इसे सॉर्ट करने के लिए इंडेक्स एरे के रूप में उपयोग करने जा रहा हूँ।)
यह चरण 1 था, यहाँ चरण 2 है:
'ndx', जिसे 'सॉर्ट' द्वारा लौटाया जाता है, उसके बाद डेटाफ्रेम, 'जीजी' को पुनः क्रम देने के लिए एक इंडेक्स ऐरे के रूप में उपयोग किया जाता है :
fg_sorted = fg[ndx,]
fg_sorted पुन: आदेश दिया गया डेटाफ़ॉर्म तुरंत ऊपर है।
संक्षेप में, 'सॉर्ट' का उपयोग इंडेक्स सरणी बनाने के लिए किया जाता है (जो आपके द्वारा सॉर्ट किए जाने वाले कॉलम के सॉर्ट ऑर्डर को निर्दिष्ट करता है), जो तब डेटाफ्रेम (या मैट्रिक्स) को री-ऑर्डर करने के लिए इंडेक्स सरणी के रूप में उपयोग किया जाता है।
(मुझे लगा कि यह @doug द्वारा पोस्ट की गई अच्छी सामग्री को संक्षेप में बताने के लिए, और #duffymo; 1 से प्रत्येक, btw द्वारा लिंक किए गए) को समझने के लिए बहुत उपयोगी हो सकता है।
? आदेश आपको बताता है कि मूल वेक्टर के किस तत्व को पहले, दूसरे, आदि को लगाने की आवश्यकता है, ताकि मूल वेक्टर को सॉर्ट किया जा सके, जबकि ? रैंक आपको बताता है कि किस तत्व में सबसे कम, दूसरा सबसे कम है, आदि, मान। उदाहरण के लिए:
> a <- c(45, 50, 10, 96)
> order(a)
[1] 3 1 2 4
> rank(a)
[1] 2 3 1 4
इसलिए order(a)कह रहा है, 'तीसरे तत्व को पहले रखो जब आप सॉर्ट करते हैं ...', जबकि rank(a)कह रहा है, 'पहला तत्व दूसरा सबसे कम है ...'। (ध्यान दें कि वे दोनों इस बात पर सहमत हैं कि कौन सा तत्व सबसे कम है, आदि। वे बस जानकारी को अलग तरह से प्रस्तुत करते हैं।) इस प्रकार हम देखते हैं कि हम order()छाँटने के लिए उपयोग कर सकते हैं , लेकिन हम rank()उस तरह से उपयोग नहीं कर सकते हैं :
> a[order(a)]
[1] 10 45 50 96
> sort(a)
[1] 10 45 50 96
> a[rank(a)]
[1] 50 10 45 96
सामान्य तौर पर, तब तक order()बराबर नहीं होगा rank()जब तक कि वेक्टर पहले से ही सॉर्ट नहीं किया गया है:
> b <- sort(a)
> order(b)==rank(b)
[1] TRUE TRUE TRUE TRUE
इसके अलावा, चूंकि order()(आवश्यक रूप से) डेटा के रैंकों पर काम कर रहा है, आप जानकारी को प्रभावित किए बिना उनकी रचना कर सकते हैं, लेकिन आस-पास का दूसरा तरीका अस्पष्ट पैदा करता है:
> order(rank(a))==order(a)
[1] TRUE TRUE TRUE TRUE
> rank(order(a))==rank(a)
[1] FALSE FALSE FALSE TRUE
orderऔर rankवास्तव में एक दूसरे के विपरीत हैं (कम से कम जब तक मूल्यों में हैंa अद्वितीय हैं)। यदि आप कल्पना करते हैं कि प्रत्येक के नाम (/ लेबल) ('1', '2', '3', '4') उनके मूल्यों पर हैं, तो मान order(a)बताता है कि rank(a)प्रत्येक लेबल में क्या स्थिति है (उदाहरण के लिए 1 मान) order(a)(3) आपको बताता है कि '1' 3 की स्थिति में होता है rank(a), और इसके विपरीत (जैसे कि 2 मान rank(a)) (3) आपको बताता है कि '2' 3 की स्थिति में होता है order(a))। वे उलटा क्रमपरिवर्तन हैं: rank(order(a))= order(rank(a))=।1 2 3 4
इस छोटे से कोड को चलाने से मुझे ऑर्डर फंक्शन को समझने की अनुमति मिली
x <- c(3, 22, 5, 1, 77)
cbind(
index=1:length(x),
rank=rank(x),
x,
order=order(x),
sort=sort(x)
)
index rank x order sort
[1,] 1 2 3 4 1
[2,] 2 4 22 1 3
[3,] 3 3 5 3 5
[4,] 4 1 1 2 22
[5,] 5 5 77 5 77
संदर्भ: http://r.789695.n4.nabble.com/I-don-t-understand-the-order-function-td4664384.html
xमें cbind()।
यह कुछ बिंदु पर आपकी मदद कर सकता है।
a <- c(45,50,10,96)
a[order(a)]
जो आपको मिलता है
[1] 10 45 50 96
मैंने जो कोड लिखा है वह बताता है कि आप "a" को "a" के पूरे सबसेट के रूप में चाहते हैं और आप चाहते हैं कि यह सबसे कम से लेकर उच्चतम मूल्य तक का ऑर्डर दे।
वे समान हैं लेकिन समान नहीं हैं
set.seed(0)
x<-matrix(rnorm(10),1)
# one can compute from the other
rank(x) == col(x)%*%diag(length(x))[order(x),]
order(x) == col(x)%*%diag(length(x))[rank(x),]
# rank can be used to sort
sort(x) == x%*%diag(length(x))[rank(x),]
all(x==x[order(x)][rank(x)])हमेशा सत्य होता है। कुछ क्रमपरिवर्तन अपने स्वयं के व्युत्क्रम हैं, लेकिन अधिकांश नहीं हैं। क्रम से बाहर आने वाली क्रमपरिवर्तन क्रमबद्धता () रैंक () है। यह बताता है कि वे कभी-कभी समान और अन्य क्यों नहीं होते हैं।