About minimizing calculations when using ComposeList

Question

I have a lot of functions to use in a iterative way, and I need some of the calculation results. For example:

 func = Function[{s}, s Sin[#] &] /@ Range[100];
 ComposeList[func, x][[1 ;; ;; 10]] 

Apparently, this code calculates much more than necessary. Especially, a lot of time is needed for the calculation when the length of func list is very long and when the Function is very complicated (e.g. Length@func = 1024 and the function is Fourier);

Is there any elegant way to reduce the calculation?

Edit

Perhaps I should say more about the fact that this code calculates than necessary.

For example,

  func = Function[{s}, s Sin[#] &] /@ Range[10];
   result=ComposeList[func, x][[1 ;; ;; 5]]

(*

{x, 5 Sin[4 Sin[3 Sin[2 Sin[Sin[x]]]]], 10 Sin[9 Sin[ 8 Sin[7 Sin[6 Sin[5 Sin[4 Sin[3 Sin[2 Sin[Sin[x]]]]]]]]]]}

*)

Now we can see that result[[2]] (i.e., 5Sin[4 Sin[3 Sin[2 Sin[Sin[x]]]]]) is also appeared inside result[[3]] (i.e., 10Sin[...5Sin[4 Sin[3 Sin[2 Sin[Sin[x]]]]]], so the evaluation for 5Sin[4 Sin[3 Sin[2 Sin[Sin[x]]]]] is repeated twice here.

The repetition will be very large with an increase of Length[func], which will be much more time-consuming than it is required. This is my point here (Up to now, Rojo has gotten the point and solved it ).

Answer 1

Maybe Reap and Sow could be used here:

func = Function[{s}, s Sin[Sow[#]] &] /@ Reverse@Range[100];

lst = Reap[(Composition @@ func)[x]];

lst[[2, 1]][[1 ;; ;; 10]]

The Composition is walked through only once, and we collect the intermediate results in passing. Not sure if this more elegant - with the example you give, the result in Reap looks the same as what your ComposeList would have produced.

Answer 2

I am not sure I understood the problem but I have the hunch that the best answer is: no it won't calculate that many times. If the source of inefficiency you see is the fact of getting 9 out of 10 intermediate results are being dropped in the end, I see the point.

If this is the point, then you could do

ComposeList[
 Composition @@@ Reverse /@ Partition[func, 10, 10, 1, {}], x]

Otherwise, you're mistaken... Try, for example,

func = Function[{s}, s (Print[#]; Sin[#]) &] /@ Range[10];
ComposeList[func, x]

and see how you get each function evaluated only once, and you don't get the innermost Sin evaluated 10 times (if that was the case, the Print would be evaluated with it since both are part of the same function`)

Answer 3

I my results this is therefore important because it shows a solution to the problem how to formulate the famous Ramanujan representation of the number 3.

n = 19; func = Function[{s}, Sqrt[1 + s*#] &] /@ (n + 1 - Range[n]);
ComposeList[func, x][[1 ;; ;; n]]
N[(ComposeList[func, x][[1 ;; ;; n]] /. x -> 1), n]

func is a way to write in Mathematica a list with a parameter both in rising and in decreasing order that is suitable for Composition or ComposeList to be evaluated!.

It other usage, the pure function symbol cases trouble for the evaluation step.

The sequence convergence strictly monotone rising to 2. Ramanujan problem was just omit the first step and have 3 for the rest of the sequence. Look at Ramanujan the greatest mathematical prodigy. So the solved miracle is in the last row of my input. The magic stems from the leading parameter $n$ of my input.

Mathematica has layout problems for this size of the parameter already.

The part built-in is the big step ahead seemingly. This one uses the Span built-in.