मेरी सोच का वेक्टरिज़ करें: आर

Question

में वेक्टर ऑपरेशंस तो पहले मैंने आर में वैक्टरों में सोचने पर अपने स्वयं के प्रश्न का उत्तर दिया। लेकिन अब मुझे एक और समस्या है जिसे मैं 'सदिश नहीं' कर सकता हूं। मुझे पता है कि वेक्टर तेज हैं और धीमे हो जाते हैं, लेकिन मुझे यह नहीं पता कि वेक्टर विधि में इसे कैसे किया जाए:

मेरे पास डेटा फ्रेम है (जो भावनात्मक कारणों से मैं my.data को कॉल करना चाहता हूं) जो मैं चाहता हूं पर एक पूर्ण सीमांत विश्लेषण करने के लिए। मुझे एक समय में कुछ तत्वों को हटाने और डेटा फ्रेम को 'मूल्य' करने की आवश्यकता है, फिर मुझे केवल अगले तत्व को हटाकर फिर से पुनरावृत्ति करने की आवश्यकता है। फिर फिर से करें ... और फिर ... विचार मेरे डेटा के सबसेट पर पूर्ण सीमांत विश्लेषण करना है। किसी भी तरह, मैं एक वेक्टर कुशल तरीके से ऐसा करने के बारे में कल्पना नहीं कर सकता।

मैं कोड के पाशन हिस्सा नीचे छोटा कर दिया है और यह इस तरह दिखता है:

for (j in my.data$item[my.data$fixed==0]) { # <-- selects the items I want to loop 
              #  through 
    my.data.it <- my.data[my.data$item!= j,] # <-- this kicks item j out of the list 
    sum.data <-aggregate(my.data.it, by=list(year), FUN=sum, na.rm=TRUE) #<-- do an 
                     # aggregation 

    do(a.little.dance) && make(a.little.love) -> get.down(tonight) # <-- a little 
                    # song and dance 

    delta <- (get.love)           # <-- get some love 
    delta.list<-append(delta.list, delta, after=length(delta.list)) #<-- put my love 
                    # in a vector 
} 

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

Answer 1

यहां रकम उत्पन्न करने के लिए एक और बहुत ही आर प्रकार के तरीके की तरह लगता है। एक वेक्टर उत्पन्न करें जो आपके इनपुट वेक्टर तक है, जिसमें एन तत्वों की दोहराई गई राशि के अलावा कुछ भी नहीं है। फिर, रकम वेक्टर से अपने मूल वेक्टर घटाएं। परिणाम: एक वेक्टर (आइसम्स) जहां प्रत्येक प्रविष्टि आपके मूल वेक्टर कम ith तत्व है।

> (my.data$item[my.data$fixed==0]) 
[1] 1 1 3 5 7 
> sums <- rep(sum(my.data$item[my.data$fixed==0]),length(my.data$item[my.data$fixed==0])) 
> sums 
[1] 17 17 17 17 17 
> isums <- sums - (my.data$item[my.data$fixed==0]) 
> isums 
[1] 16 16 14 12 10 

Answer 2

यह कोई जवाब नहीं है, लेकिन मुझे आश्चर्य है कि अगर किसी भी अंतर्दृष्टि इस दिशा में निहित है:

> tapply((my.data$item[my.data$fixed==0])[-1], my.data$year[my.data$fixed==0][-1], sum) 

tapply आंकड़ों की एक तालिका का उत्पादन (रकम, इस मामले में, तीसरा तर्क) के रूप में दिया पैरामीटर के आधार पर वर्गीकृत दूसरा तर्क। उदाहरण के लिए

2001 2003 2005 2007 
1 3 5 7 

[-1] नोटेशन चयनित पंक्तियों में से एक को अवलोकन (पंक्ति) छोड़ देता है। तो, आप पाश सकता है और [मैं] का उपयोग प्रत्येक पाश पर मन में

for (i in 1:length(my.data$item)) { 
    tapply((my.data$item[my.data$fixed==0])[-i], my.data$year[my.data$fixed==0][-i], sum) 
} 

रखते हुए कि आप केवल 1 अवलोकन के साथ किसी भी वर्ष है, तब टेबल लगातार tapply कॉल द्वारा दिया ही नहीं होगा स्तंभों की संख्या। (यानी, यदि आप 2001 के लिए एकमात्र अवलोकन छोड़ते हैं, तो 2003, 2005, और 2007 केवल टी कॉलम लौटाएंगे)।

Answer 3

अजीब रूप से पर्याप्त, आर में वेक्टरिज़ करना सीखने से मुझे बुनियादी कार्यात्मक प्रोग्रामिंग में उपयोग करने में मदद मिली। एक बुनियादी तकनीक एक समारोह के रूप पाश अंदर अपने संचालन को परिभाषित करने के होगा:

data = ...; 
items = ...; 

leave_one_out = function(i) { 
    data1 = data[items != i]; 
    delta = ...; # some operation on data1 
    return delta; 
} 


for (j in items) { 
    delta.list = cbind(delta.list, leave_one_out(j)); 
} 

vectorize करने के लिए, तुम सब sapply मानचित्रण समारोह के साथ for पाश की जगह है:

delta.list = sapply(items, leave_one_out);