आर: वेक्टर

Question

पर एक गणना करना मुझे लगता है कि मेरे पास आर के लिए एक बहुत ही बुनियादी सवाल है लेकिन मुझे एक उदाहरण खोजने में परेशानी हो रही है। मान लें कि मेरे पास संख्या

practice<-c(1,2,10,15,17,1,2,4) 

और मैं संख्याओं के बीच परिवर्तन की गणना करना चाहता हूं। वेक्टर की लंबाई 36 अवलोकनों पर तय की गई है। मैं जो गणना करना चाहता हूं उसका उदाहरण है ((2/1) -1), ((10/2-1), .... मैं लूप के निर्माण के बारे में सोच रहा हूं जहां मैं स्थिति का संदर्भ देता हूं और इसके साथ एक काउंटर जुड़ा हुआ है यह।

Answer 1

आर उपयोग कर के लाभ में से एक अपने vectorization जिसका अर्थ है कि यह आसानी से संचालन एक पूरे वेक्टर पर एक ही बार में नहीं बल्कि प्रत्येक तत्व लूप करने के लिए की तुलना में प्रदर्शन कर सकते हैं है।

डेविड Arenburg एक में उल्लेख किया

practice[-1]/head(practice, -1) - 1 

यह क्या करता है

: टिप्पणी (BondedDust और डोमिनिक Comtois के लिए अद्यतन धन्यवाद के साथ), आपके मामले में आप कर सकते हैं यह करने के?

practice[-1] पहले तत्व को छोड़कर पूरे वेक्टर का संदर्भ देता है।

> practice[-1] 
[1] 2 10 15 17 1 2 4 

इसी प्रकार, head(practice, -1) अंतिम तत्व को छोड़कर पूरे वेक्टर का संदर्भ देता है।

> head(practice, -1) 
[1] 1 2 10 15 17 1 2 

हम इन विभाजित है, तो हम तत्व इससे पहले आने से विभाजित मूल सदिश में प्रत्येक तत्व से मिलकर एक सदिश मिलता है। हम इन वेक्टरों को सीधे विभाजित कर सकते हैं क्योंकि विभाजन एक वेक्टरकृत ऑपरेशन है।

> practice[-1]/head(practice, -1) 
[1] 2.0000 5.0000 1.5000 1.1333 0.0588 2.0000 2.0000 
> # ^ ^ ^ ^ ^ ^ ^
> # 2/1 10/2 15/10 17/15 1/17 2/1 4/2 

जैसा कि आपके उदाहरण में है, हम अंत में 1 घटा सकते हैं।

> practice[-1]/head(practice, -1) - 1 
[1] 1.0000 4.0000 0.5000 0.1333 -0.9412 1.0000 1.0000 

यह इसके बाद से वेक्टर में प्रत्येक तत्व के लिए लागू किया जाता है भी आर

में एक vectorized आपरेशन

कोई आवश्यक लूप है!

बराबर पाश कोड इस होगा:

x <- NULL 
for (i in 1:(length(practice) - 1)) { 
    x[i] <- practice[i + 1]/practice[i] - 1 
} 
x 
[1] 1.0000 4.0000 0.5000 0.1333 -0.9412 1.0000 1.0000 

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