आर में इंटीग्रेटिंग/इंटीग्रल: पकड़

Question

ठीक है, इसलिए यह मुझे 3 दिनों से अधिक समय तक फंस गया है और अभी भी समाधान के करीब एक कदम नहीं होने के बाद, मैं यहां अपनी किस्मत आजमा रहा हूं।

अतीत में, मैं विशिष्ट में एक क्रमबद्ध डाटासेट के लिए कुछ कोड लिखा है और यह इस प्रकार है:

n <- length(data) 
maxobs <- max(data) 
minobs <- min(data) 
FG <- function(m=NULL, h = NULL){ 
    n<- length(data) #Number of observations 
    if (m<minobs){FG = 0} else { 
     if (m >maxobs){FG = 1} else { 
        FG = sum(pnorm((m - data)/h)-pnorm((minobs-data)/h))/sum(pnorm((maxobs - data)/h)-pnorm((minobs-data)/h)) 
    }} 
    return(FG) 
} 

f<- function(m,h){ 
    f<- FG(m,h)^n 
    return(f) 
} 

##Integration 
max <- NULL 
delta<- function(h,max=maxobs){ 
    delta <- integrate(Vectorize(f), minobs, max, h)$value 
    return (delta) 
} 

जो पूरी तरह से काम करता है। उदाहरण के लिए, अगर एक का चयन करता है डेटा: = ग (1,2,3,4,5), एक

> delta(0.1, maxobs) 
[1] 0.6300001 

हालांकि के लिए सही परिणाम हो जाता है, अब मैं प्रत्येक अनुसार क्रमबद्ध डेटासेट के लिए यह सामान्यीकरण करने के लिए कोशिश कर रहा हूँ, तो क्या मैंने किया था (स्पष्ट होना: डाटासेट एक्स से पहले कसरत सब इन कार्यों क्रमबद्ध किया जाता है)

FG <- function(x, m=NULL, h = NULL){ 
    n<- length(x) #Number of observations 
    maxobs <- max(x) 
    minobs <- min(x) 
    if (m<minobs){FG = 0} else { 
    if (m >maxobs){FG = 1} else { 
     FG = sum(pnorm((m - x)/h)-pnorm((minobs-x)/h))/sum(pnorm((maxobs - x)/h)-pnorm((minobs-x)/h)) 
    }} 
    return(FG) 
} 

f<- function(x,m,h){ 
    n <- length(x) 
    f<- FG(x,m,h)^n 
    return(f) 
} 

##Integration 
delta<- function(x,h,maxu= max(x)){ 
minobs <- min(x) 
    delta <- integrate(Vectorize(f), minobs, maxu, h)$value 
    return (delta) 
} 

लेकिन अब, delta(data,0.1)

delta(data,0.1) 
[1] 0. 

कौन नहीं करता है देता है मुझे कोई समझ नहीं है। वही कार्य, एक ही डेटासेट, लेकिन अब गलत मान के साथ। मैं क्या गलत कर रहा हूं?

किसी भी मदद की सराहना की जाएगी।

संपादित करें: vectorize कार्य करने के लिए करीब से देख लेने और समारोह को एकीकृत करने के बाद, अब मैं अपने डेल्टा कार्य करने के लिए संपादित किया है:

delta<- function(x,h,maxu= max(x)){ 
minobs <- min(x) 
    delta <- integrate(Vectorize(f, vectorize.args= c("m","h")), minobs, maxu, h)$value 
    return (delta) 
} 

लेकिन यह अब सिर्फ एक और त्रुटि में परिणाम है:

Error in integrate(Vectorize(f, vectorize.args = c("m", "h")), lower = minobs, : evaluation of function gave a result of wrong length

मैंने सोचा कि वेक्टरिज़ ऐसी त्रुटियों को रोकने के लिए माना जाता था?

Answer 1

यहां मुख्य समस्या यह है कि integrate आपको उम्मीद है कि आप उस चर के पास हैं जो आप पहले तर्क के रूप में एकीकृत कर रहे हैं। कोड के पहले सेट में, आप m से अधिक एकीकृत कर रहे हैं। दूसरे सेट में, आप x से अधिक एकीकृत करने का प्रयास कर रहे हैं।

delta<- function(x,h,maxu= max(x)){ 
    minobs <- min(x) 
    g <- function(m) f(x,m,h) 
    return(integrate(Vectorize(g), minobs, maxu)$value) 
} 

अब आप अपने वांछित परिणाम

delta(data,0.1) 
# [1] 0.6300001 

मैं स्रोत का मानना ​​है कि प्राप्त करेंगे:

कम से कम संपादित integrate के लिए आवश्यक क्रम में तर्क जगह एक सहायक समारोह बनाने के लिए है आपकी दूसरी त्रुटि का h पर वेक्टरिज़ करने का प्रयास करने के कारण था, जबकि आप वास्तव में केवल m से अधिक सदिश बनाना चाहते थे। उपरोक्त सहायक कार्य दृष्टिकोण इस समस्या को समाप्त करता है साथ ही उस चर को उजागर करके जिसे आप एकीकृत करना चाहते हैं।

ध्यान दें कि मैं बता नहीं कर सकते तुम सच में यहाँ करने के लिए कोशिश कर रहे हैं, लेकिन मैं भी इस पुनर्लेखन कि आपके कार्यान्वयन के बराबर होना चाहिए की पेशकश करेंगे, लेकिन शायद थोड़ा आसान का पालन करने के:

FG <- function(m, x, h) { 
    n <- length(x) 
    d <- function(t) pnorm((t-x)/h) 

    if(m < x[1]) return(0) 
    if(m > x[n]) return(1) 

    return(sum(d(m)-d(x[1]))/sum(d(x[n])-d(x[1]))) 
} 

f<- function(m, x, h){ 
    n <- length(x) 
    mapply(function(m) FG(m,x,h)^n, m) 
} 

delta<- function(x, h, lb=x[1], ub=x[length(x)]) { 
    return(integrate(f, lb, ub, x, h)$value) 
}