स्वतन्त्रता का एक मुक्त नमूना

Question

एक 1-आयामी, वास्तविक-मूल्यवान वेक्टर x पर विचार करें जो समय के साथ समान अंतराल पर मापी गई कुछ प्रक्रिया की टिप्पणियों का प्रतिनिधित्व करता है। हम कहते हैं एक्स एक समय श्रृंखला ।

चलो n की लंबाई निरूपित एक्स और एक्स निरूपित का समांतर माध्य एक्स । नमूना autocovariance समारोह के रूप में परिभाषित किया गया है

सभी के लिए - n < h < n । यह एक ही श्रृंखला पर दो बिंदुओं के बीच रैखिक निर्भरता को अलग-अलग समय पर मनाया जाता है।

नमूना autocorrelation समारोह , या ACF, के रूप में परिभाषित किया गया है

इस उपायों की श्रृंखला रैखिक पूर्वानुमान एक्स समय में टी है, जो हम निरूपित एक्स _टी , केवल मूल्य का उपयोग कर एक्स _{टी + h} ।

ध्यान दें कि ये नमूना अनुमान सैद्धांतिक गुणों के आधार पर भोले गणना से मेल नहीं खाते हैं। है यही कारण है, नमूना autocorrelation समारोह है नहीं के बराबर पियर्सन सहसंबंध गुणांक के एक्स के साथ ज -चरण के अंतराल एक्स ।

कार्य

यह देखते हुए एक सरणी एक्स और ग़ैर-ऋणात्मक पूर्णांक ज , प्रिंट या पहले लौट ज +1 अंतराल के autocorrelations एक्स , अंतराल 0. अंतराल autocorrelations उन ऊपर सूत्रों में नकारात्मक आदानों के लिए इसी रहे हैं के साथ शुरुआत।

आप मान सकते हैं कि 0 < h < n , जहां n की लंबाई x है , और वह 2 < n <256 है।

1E-4 के भीतर आउटपुट सही होना चाहिए। अंतर्निहित कार्यों या चलने के समय के उपयोग पर कोई प्रतिबंध नहीं है।

उदाहरण

h, x -> output
--------------
5, [2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2] -> [1.00000000,  0.07659298, -0.06007802, -0.51144343, -0.02912874, -0.10468140]
1, [2134, 1863, 1877, 1877, 1492, 1249] -> [1.0000000, 0.3343041]
2, [13067.3, 13130.5, 13198.4] -> [1.0000000000, -0.0002854906, -0.4997145094]

Answer 1

जेली, 26 25 24 23 20 बाइट्स

×L_SµḊ;0µƓС׹S€µF÷Ḣ

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

×L_SµḊ;0µƓС׹S€µF÷Ḣ  Main link. Input: x (list) STDIN: h (integer)

×L                    Multiply all items in x by the length of x.
  _S                  Subtract the sum of x from all products.
                      Let's call the result X.
    µ                 Begin a new monadic chain. Argument: t (list)
     Ḋ                Remove the first element of t.
      ;0              Append a 0 to the result.
        µ             Push the previous chain and begin a new one.
                      Argument: X
         Ɠ            Read h from STDIN.
          С          Repeat the Ḋ;0 chain h times, collecting the h+1 intermediate
                      results in a list A.
            ×¹        Multiply the vectors in A by X.
              S€      Compute the sum of each vectorized product.
                µ     Begin a new, monadic chain. Argument: S (sums)
                 F    Flatten S. This does nothing except creating a deep copy.
                   Ḣ  Pop the first element of S.
                  ÷   Divide all elements of the copy by the first element.

Answer 2

आर, 3 31 25 बाइट्स

# changes the builtin to only return the acf
body(acf)=body(acf)[1:18]

उपयोग (autocorrelations के साथ एक सरणी देता है)

(acf(c(2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2),5))
# , , 1
#
#             [,1]
# [1,]  1.00000000
# [2,]  0.07659298
# [3,] -0.06007802
# [4,] -0.51144343
# [5,] -0.02912874
# [6,] -0.10468140

पृष्ठभूमि:

acfमें निर्मित मूल के आधार पर 31 बाइट समाधान

function(n,h)c(acf(n,h,,F)$acf)

ध्यान दें कि acfएक सूची में एक तत्व के रूप में आवश्यक ऑटोक्रॉलेशन को वापस करते समय 3 बाइट विकल्प उस में मूल रूप है (और 3 अंक तक प्रिंट करेगा)।

प्रयोग

 acf(c(2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2),5)

उत्पादन:

#    Autocorrelations of series ‘c(2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2)’, by lag
#
#     0      1      2      3      4      5 
# 1.000  0.077 -0.060 -0.511 -0.029 -0.105 

अगर हम चाहते हैं कि सहसंबंध 3 से अधिक दशमलव स्थानों पर प्रदर्शित हों, तो 28 बाइट्स करेंगे (या 31, यदि हम भूखंड को दबाना चाहते हैं)

# will still plot (28 bytes)
function(n,h)c(acf(n,h)$acf)
# won't plot (31 bytes)
function(n,h)c(acf(n,h,,F)$acf)

Comments

यह शायद सबसे चतुर चाल है जिसे मैंने कभी देखा है। मुझे नहीं पता था कि कोई ऐसा कर सकता है। हम आर को मासिक की भाषा के रूप में चयनित करने की कोशिश कर रहे हैं - आप इसे करने के लिए इस मेटा उत्तर को बढ़ा सकते हैं।

— JayCe

Answer 3

पायथन 3, 147 130 126 120 बाइट्स

def p(h,x):x=[t-sum(x)/len(x)for t in x];return[sum(s*t for s,t in zip(x[n:],x))/sum(b*b for b in x)for n in range(h+1)]

यह समाधान संभवत: आगे गोल्फ होने जा रहा है, यह सिर्फ एक शुरुआत है।

आप इसे कॉल कर सकते हैं:

p(5,[2.4, 2.4, 2.4, 2.2, 2.1, 1.5, 2.3, 2.3, 2.5, 2])

Answer 4

MATL , 20 बाइट्स

tYm-tPX+tX>/GnqiQ:+)

EDIT (20 मई, 2016): भाषा के संस्करण 18.0.0 के रूप में, के Y+बजाय का उपयोग करें X+। लिंक में यह परिवर्तन शामिल है।

इसे ऑनलाइन आज़माएं!

सहसंबंध निकटता से संबंधित है। हम औसत घटाकर सामान्य करते हैं, फिर दृढ़ हो जाते हैं, फिर से अधिकतम मूल्य से विभाजित करके सामान्य करते हैं, और फिर वांछित अंतराल उठाते हैं।

tYm-       % implicit input. Duplicate and subtract mean
tPX+       % duplicate, flip, convolve
tX>/       % duplicate, divide by maximum value
Gnq        % length of array, n. Subtract 1
iQ:        % input number h. Generate vector [1,2,...,h+1]
+          % add to obtain vector [n,n+1,...,n+h]
)          % use that vector as an index. Implicitly display

Answer 5

गणितज्ञ, 27 बाइट्स

1 बाइट बचाने के लिए LegionMammal978 का धन्यवाद।

अगर समारोह के नाम इतने लंबे नहीं होते तो हम जैली को हरा सकते थे।

#2~CorrelationFunction~{#}&

---

परीक्षण का मामला

%[5,{2.4,2.4,2.4,2.2,2.1,1.5,2.3,2.3,2.5,2}]
(* {1.,0.076593,-0.060078,-0.511443,-0.0291287,-0.104681} *)

Comments

इससे पहले कि मेरा इंटरनेट डाउन होता मैं इसे पोस्ट करने वाला था ... आप एक बाइट को बचा सकते हैं #2~CorrelationFunction~{#}&।

— लेजिओनमल 978

Answer 6

ऑक्टेव, 47 37 बाइट्स

@(h,x)xcov(x,'coeff')(numel(x)+(0:h))

Comments

@ रैनर शायद आप एक अनाम फ़ंक्शन का उपयोग करके कुछ बाइट्स बचा सकते हैं (और उस स्थिति में मुझे लगता है कि आप छोड़ सकते हैं disp, क्योंकि आप एक फ़ंक्शन आउटपुट लौटा रहे हैं)

— लुइस

@LuisMendo तुम सही हो। 10 बाइट्स की बचत की, यहां तक ​​कि गिनती के बिना भी disp।

— रेनर पी।