# NestList with a list inside?

I'm new to Mathematica, and was looking for more efficient ways to implement the Do loop below. a, b, c and d are all constants, but I'm also using a list in the loop. Is this possible to implement with NestList? I haven't been able to find any examples with a list being used inside of NestList.

Do[
X = Tanh[a.input[[i]] + b.X + c];
Y = d.X;
YOut = Append[YOut, Y];
,{i, Length[input]}];


Thanks!

*

Sorry for the confusion, I tried to simplify my code for the sake of brevity.

Do[
X = Tanh[Win.input[[i]] + Wres.X + Wbias]];
Y = WOUT.X;
YOut = Append[YOut, Y];
, {i, Length[input]}
];


Win, Wres, Wbias, and WOUT are all appropriately sized matrices. This do loop is part of a testing routine for Reservoir Computing, a type of machine learning.

With help from your answer, I'm rewriting the above as:

f = WOUT.(Tanh[Wbias + Win.#2 + WRes.#1]) &;
YOut = FoldList[f, X, input];


Will try it out now. Thanks for the help!

EDIT - If anyone is looking for a reservoir computing implementation in Mathematica, I've added mine to Github - https://github.com/huvers/reservoir_computing

• Asking a question you should provide always a minimal example of intended input. It saves time and effort of all mathematica.se users. Commented Aug 30, 2013 at 19:48
• Nothing against NestList or FoldList, but a simple Table could do this too. Commented Mar 9, 2022 at 14:28

## 1 Answer

Taking into account clarification after editting the question I guess the most direct solution you are looking for is Fold (or FoldList) rather than Nest (or NestList) even though you might succeed with the latter. Regardless of objects a, b, c, d, X, Y etc. or Win, Wbias, WOUT, WRes being scalars or matrices we can proceed defining an appropriate function for the Fold construct.
At first let's define an example of matrix objects:

{a, b, c, d} =
{{{1, 2}, {-1, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{-2, 1}, {1, -1}}};
id = IdentityMatrix[2];
input = {0 id, 1 id, 2 id};


Next we can define for the following pure function:

 f = d.Tanh[ a.#2 + b.#1 + c]&;


then it yields YOut:

FoldList[ f, {{x11, x12}, {x21, x22}}, input]


while this yields the last entry of YOut:

Fold[f, {{x11, x12}, {x21, x22}}, input]


For example choosing

X = {{0, 0}, {0, 0}};


we have

Fold[ f, {{0, 0}, {0, 0}}, input]

{{-2 Tanh[2 + Tanh[Tanh[1]] - 2 Tanh[1 + Tanh[1]]]
- Tanh[1 - Tanh[Tanh[1]] + Tanh[1 + Tanh[1]]],
-2 Tanh[ 5 - 2 Tanh[3 - 2 Tanh[1]] + Tanh[1 - Tanh[1]]]
+ Tanh[2 - Tanh[3 - 2 Tanh[1]] + Tanh[1 - Tanh[1]]]},
{ Tanh[2 + Tanh[Tanh[1]] - 2 Tanh[1 + Tanh[1]]]
+ Tanh[1 - Tanh[Tanh[1]] + Tanh[1 + Tanh[1]]],
Tanh[5 - 2 Tanh[3 - 2 Tanh[1]] + Tanh[1 - Tanh[1]]]
- Tanh[2 - Tanh[3 - 2 Tanh[1]] + Tanh[1 - Tanh[1]]]}}


Let's choose another example of scalar objects:

Clear[f, X, a, b, c, d, id, input]

input = {0, 1, 2};
{a, b, c, d} = {1, 2, 3, 4};
f = d Tanh[a #2 + b #1 + c] &;


then we have e.g.

Fold[ f, 0, input]

4 Tanh[ 5 + 8 Tanh[ 4 + 8 Tanh[3]]]