Betrachten Sie einen eindimensionalen, reellen Vektor x , der Beobachtungen eines Prozesses darstellt, die in zeitlich gleichmäßigen Abständen gemessen werden. Wir nennen x eine Zeitreihe .

Lassen n die Länge bezeichnen x und x bezeichnen das arithmetische Mittel der x . Die Probe Autokovarianz - Funktion definiert ist als

für alle - n < h < n . Dies misst die lineare Abhängigkeit zwischen zwei Punkten derselben Reihe, die zu unterschiedlichen Zeiten beobachtet wurden.

Die Probe Autokorrelationsfunktion oder ACF, ist definiert als

Dies misst die lineare Vorhersagbarkeit der Reihe x zum Zeitpunkt t , die wir mit x _{t bezeichnen} , wobei nur der Wert x _{t + h verwendet wird} .

Beachten Sie, dass diese Stichprobenschätzungen nicht mit den naiven Berechnungen auf der Grundlage der theoretischen Eigenschaften übereinstimmen. Das heißt, die Autokorrelationsfunktion der Probe ist nicht gleich dem Pearson-Korrelationskoeffizienten von x mit der h- Schritt-Verzögerung von x .

Aufgabe

Wenn ein Array x und eine nichtnegative ganze Zahl h gegeben sind , drucken oder geben Sie die ersten h + 1- Verzögerungsautokorrelationen von x zurück , beginnend mit der Verzögerung 0. Die Verzögerungsautokorrelationen sind diejenigen, die negativen Eingaben in den obigen Formeln entsprechen.

Sie können annehmen, dass 0 < h < n , wobei n die Länge von x ist , und dass 2 < n <256.

Die Ausgabe sollte innerhalb von 1E-4 korrekt sein. Es gibt keine Einschränkungen hinsichtlich der Verwendung integrierter Funktionen oder der Laufzeit.

Beispiele

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]

Gelee, 26 25 24 23 20 Bytes

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

Probieren Sie es online aus!

Wie es funktioniert

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

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

Verwendung (gibt ein Array mit den Autokorrelationen zurück)

(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

Hintergrund:

Die 31-Byte-Lösung basiert auf dem acfeingebauten Original

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

Beachten Sie, dass die 3-Byte-Option acf die ursprünglich erstellte ist, die geplottet (und auf 3 Stellen gedruckt) wird, während die erforderliche Autokorrelation als Element in einer Liste zurückgegeben wird.

Verwendung

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

Ausgabe:

#    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 

Wenn die Korrelationen auf mehr als 3 Dezimalstellen angezeigt werden sollen, reichen 28 Bytes aus (oder 31, wenn wir den Plot unterdrücken möchten).

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

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

Diese Lösung wird wahrscheinlich weiter ausgebaut. Es ist nur ein Anfang.

Sie können es nennen mit:

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

MATL , 20 Bytes

tYm-tPX+tX>/GnqiQ:+)

BEARBEITEN (20. Mai 2016): Ab Version 18.0.0 der Sprache Y+anstelle von verwenden X+. Der Link enthält diese Änderung.

Probieren Sie es online aus!

Die Korrelation hängt eng mit der Faltung zusammen. Wir normalisieren durch Subtrahieren des Mittelwerts, falten uns dann, normalisieren erneut durch Teilen durch den Maximalwert und wählen dann die gewünschten Verzögerungen aus.

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

Mathematica, 27 Bytes

Vielen Dank an LegionMammal978 für das Speichern von 1 Byte.

Wir könnten Jelly schlagen, wenn die Funktionsnamen nicht so lang wären.

#2~CorrelationFunction~{#}&

Testfall

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

Oktave, 47 37 Bytes

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