Xem xét một vectơ 1 chiều, có giá trị thực x đại diện cho các quan sát của một số quá trình được đo tại các khoảng cách đều nhau theo thời gian. Chúng tôi gọi x một chuỗi thời gian .

Gọi n là độ dài của x và x̄ biểu thị giá trị trung bình số học của x . Các mẫu autocovariance chức năng được định nghĩa là

cho tất cả - n < h < n . Điều này đo lường sự phụ thuộc tuyến tính giữa hai điểm trên cùng một chuỗi được quan sát tại các thời điểm khác nhau.

Các mẫu tự tương quan chức năng , hoặc ACF, được định nghĩa là

Điều này đo lường khả năng dự đoán tuyến tính của chuỗi x tại thời điểm t , mà chúng tôi biểu thị x _t , chỉ sử dụng giá trị x _{t + h} .

Lưu ý rằng các ước tính mẫu này không khớp với các tính toán ngây thơ dựa trên các thuộc tính lý thuyết. Nghĩa là, hàm tự tương quan mẫu không bằng hệ số tương quan Pearson của x với độ trễ h -step của x .

Bài tập

Cho một mảng x và một số nguyên h không âm , in hoặc trả về tự động độ trễ h +1 đầu tiên của x , bắt đầu bằng độ trễ 0. Tự động tương quan độ trễ là những giá trị tương ứng với các đầu vào âm trong các công thức trên.

Bạn có thể giả sử rằng 0 < h < n , trong đó n là độ dài của x và 2 < n <256.

Đầu ra phải chính xác trong vòng 1E-4. Không có hạn chế về việc sử dụng các chức năng tích hợp hoặc thời gian chạy.

Ví dụ

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]

Thạch, 26 25 24 23 20 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

×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.

R, 3 31 25 byte

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

Cách sử dụng (trả về một mảng với 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

Lý lịch:

Giải pháp 31 byte dựa trên bản gốc acfđược tích hợp sẵn

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

Lưu ý rằng tùy chọn 3 byte acflà bản gốc được xây dựng trong đó sẽ vẽ đồ thị (và in thành 3 chữ số) trong khi trả về tự động tương quan cần thiết như một thành phần trong danh sách.

sử dụng

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

đầu ra:

#    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 

Nếu chúng ta muốn các tương quan hiển thị đến hơn 3 vị trí thập phân thì 28 byte sẽ thực hiện (hoặc 31, nếu chúng ta muốn triệt tiêu âm mưu)

# 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)

Python 3, 147 130 126 120 byte

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)]

Giải pháp này có thể sẽ được đánh gôn hơn nữa, Đó chỉ là một sự khởi đầu.

Bạn có thể gọi nó bằng:

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

MATL , 20 byte

tYm-tPX+tX>/GnqiQ:+)

EDIT (ngày 20 tháng 5 năm 2016): kể từ phiên bản 18.0.0 của ngôn ngữ, hãy sử dụng Y+thay vì X+. Liên kết bao gồm sự thay đổi này.

Hãy thử trực tuyến!

Tương quan có liên quan chặt chẽ với tích chập. Chúng tôi bình thường hóa bằng cách trừ trung bình, sau đó tích lũy, bình thường hóa lại bằng cách chia cho giá trị tối đa và sau đó chọn độ trễ mong muốn.

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

Toán học, 27 byte

Cảm ơn LegionMammal978 vì đã tiết kiệm 1 byte.

Chúng ta có thể đánh bại Jelly nếu tên hàm không quá dài.

#2~CorrelationFunction~{#}&

Trường hợp thử nghiệm

%[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} *)

Octave, 47 37 byte

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