Access previous items with Linq

[mdmoura]

I have the following for loop:

for (Int32 i = 0; i < inputs.Count(); i++)
  outputs.Add(inputs[index] * outputs[index - 1]);  

Is there any extension in MoreLinq that would allow me to do this with Linq?

var outputs = inputs.Select(input => input * Previous Output);

[viceroypenguin]

The .Scan extension will do what you're looking for. It returns the first value, and then the result of the operation when provided the previous result and the current value. See this example for your case.

var outputs = inputs.Scan((a, b) => a * b);

[mdmoura]

Can I also use scan if, for example, I need not the previous value but the precious and 2 before?

Thank you

[viceroypenguin]

If you review the following. It will return 11 items (the initial state plus one for each of the 10 items in the input). For each item, the new cur value will be the product of the previous current value and the new item. The prev and prev2 values will be shifted from the previous values. You could also call .Skip(2) after the .Scan() if you don't need the initial state or the results of the first value. You should be able to alter this to what you need. Does this help? If not, can you give me more details and I can help.

Enumerable.Range(1, 10)
	.Scan(
		(cur: 1, prev: 0, prev2: 0),
		(a, b) => (a.cur * b, a.cur, a.prev))

[mdmoura]

@viceroypenguin:

It helps but I am not sure I completely understood ... Let me better explain:

I am working with time series and trying to create a standard process to accomplish a few steps:

For that I would like to use Linq and I am already using a few extensions from MoreLinq ...

First I have a time series x1:

IEnumerable<Double> x1 = getTimeSeries();

1. Then using a few extension methods I create other time series in 2 possible ways:

   A. All new time series are computed from x1:

    IEnumerable<Double> y1 = x1.Transform(20);
    IEnumerable<Double> y2 = x1.Transform(0.5);
   

   B. A few new time series can be calculated from another new time series:

      IEnumerable<Double> y1 = x1.Transform(20);
      IEnumerable<Double> y2 = y1.Transform(0.5);
   

2. Then I need to place x1, y1 and y2 in an IEnumerable of Tuple. If case (1.A) I would use:

     var series = x1.Zip(x1.Transform(20)).Zip(x1.Transform(0.5))
   

   For case (1.B) I would get something strange:

     var series = x1.Zip(x1.Transform(20)).Zip(x1.Transform(20).Transform(0.5))
   

   So I am calculating x1.Transform(20) twice.

   Not sure the better way to implement this step (2)

3. Then I need to create an IEnumerable of results that can be done in 3 ways:

   A. Apply operations to each "row" of the Tuple series:

     var results = series.Select(x => x.x1 * x.y1 * y.2); 
   

   B. Apply operations to each "row" but in a sliding window:

     var results = series.Window(4).Select(x => x.x1.Max() - x.y1.Min() + y.2);
   

   C. Apply operation to each "row" using Window or not but with the need to access previous results:

     var results = series.Scan((x, y) => x * factor + (y * (1 - factor)) ?? 0);
   
     or when needing Window:
   
     var results = series.Window(10).Scan((x, y) => x.First() * factor + (y.Last() * (1 - factor)) ?? 0);
   

I think after your answer the code I just posted for step (3) seems ok ... Not sure about step (2).

What do you think? What would be, using MoreLinq, the best way to follow these steps?

Thank you

[viceroypenguin]

For the first and second parts, I would say that as long as you are working with an IEnumerable<double> Transform(this IEnumerable<double>), then there are only two ways to deal with it: run the calculation twice, or instantiate the intermediate value via .ToList() or similar. There's not really a good way to tee an IEnumerable<> without the consumers cooperating with each other.

However, if you have access to the .Transform() method, then you might modify it to a IEnumerable<(double original, double transformed)> Transform(this IEnumerable<double>) if possible. Then you would have access to something that you could double-transform, via var series = x1.Zip(x1.Transform(20).Select(x => x.transformed).Transform(0.5)). This would have the original value via x1 and both transformed values via the second .Transform().

That said, I'd say the best thing would be to figure out how to represent all three values directly in a Transform function that takes more than one argument. Then it could return a 3-tuple of (x1, y1, y2), the values of which are subject to the parameters.

The code in q3 looks fine, except that series.Window().Scan() is going to be an evaluation of two neighboring windows (i.e. first iteration: x = series[0..9], y = series[1..10]; second iteration: x = series[1..10], y = series[2..11], etc.) If that's what you want, great. If not, you might need to review a bit further.