# Recursion on a moving window

I need to apply some computations to a moving window of $N$ items in a time series and I am struggling with doing recursion and shifting the considered window.

To illustrate, please consider the simple function below.

myFunction[state_] := Append[state[[2 ;;]], RandomInteger[10]]
initialState = {1, 2, 3};
RandomInteger[10];
state1 = myFunction[initialState]
state2 = myFunction[state1]


In reality I am doing some time series analysis.

I am predicting the t4 based on t1, t2 and t3. Then I want to predict t5 based on t2, t3 and my predicted t4 and so on.

So after 3 iterations, I will be predicting based on my 3 first predictions

-
Is R.M's answer what you want? – Mr.Wizard May 4 '12 at 22:47
@Mr.Wizard, you truly are, after 30 min I realize it does not after 10 iterations for me in what I do :-( – 500 May 4 '12 at 23:30
@Mr Wizard, I guess Append[] is a bad example since it is part of the recursion I want to do ? – 500 May 4 '12 at 23:32
Somehow I didn't think that is what you wanted, but I don't yet know what you do want. Please try to provide a more representative example. Actual manually-generated output would be appreciated. – Mr.Wizard May 4 '12 at 23:40
@Mr. Wizard, i cant think of a clearer explanation sadly. I am doing a bunch of transformation of values at t1 and t2 to predict t3 then I want to do the same bunch of computations but this time on t2 and t3.... i am sorry if it is not clear :-( – 500 May 4 '12 at 23:49

From your question, it looks like you need to implement some form of a linear predictor and step forward in time starting with an initial state. The solution is still the same as my previous version — i.e., using Nest, but it's now written in a clearer form:

predict[samples_] := Total[samples] (* Replace Total with your function *)
step[state_, n_: 2] := state ~Join~ {predict[state[[-n ;;]]]}
Nest[step[#, 3] &, initialState, 10] (* enter your lag (here 3), initialState, iterations *)


An example to generate the Fibonacci series with the above:

Nest[step, {0, 1, 1}, 10]
(* {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144} *)


You can do it easily with NestList:

NestList[myFunction, initialState, 5]
(* {{1, 2, 3}, {2, 3, 1}, {3, 1, 3}, {1, 3, 3}, {3, 3, 5}, {3, 5, 5}} *)

-

Taking R.M's lead and using the Fibonacci sequence, maybe this example is helpful?

f[{a_, b_}] := {b, a + b};

NestList[f, {1, 1}, 7]

{{1, 1}, {1, 2}, {2, 3}, {3, 5}, {5, 8}, {8, 13}, {13, 21}, {21, 34}}


Or as an anonymous function:

NestList[{#2, # + #2} & @@ # &, {1, 1}, 7]

-
Isn't this the same as my first NestList` answer that you said was not what 500 wanted? – R. M. May 5 '12 at 0:24
@R.M I'm trying... (already voted for yours) – Mr.Wizard May 5 '12 at 0:46