C# Looping a través de un IEnumerable para un cálculo que usa los elementos n anterior y n

Question

Me encuentro frecuentemente tratando con un objeto IEnumerable que necesito recorrer y hacer un cálculo para cada elemento que depende de la n inmediatamente anterior y siguientes objetos

Un ejemplo común es el cálculo de una media móvil, pero otras veces el cálculo es más complejo que eso y se basa en varios campos de cada uno de los elementos de la lista

nunca estoy seguro sobre la mejor manera de estructurar mis bucles La eficiencia es importante, pero la capacidad de mantenimiento y la legibilidad son más importantes.

• A veces se convierten en una lista y luego utilizar un bucle para obtener elementos de [i-1], [i], [i + 1] y luego realizo mis cálculos.

• Otras veces lo conservo como un IEnumerable, pero guardo en "caché" el par de elementos anteriores, por lo que no hago el cálculo hasta que llegué a [i + 1] en el ciclo foreach .

• También consideré el uso de una lista vinculada, por lo que podría utilizar los métodos .Previous y .Next.

¿Alguna sugerencia sobre qué técnica sería la mejor para usar?

Answer 1

Aquí es una implementación simple:

public static IEnumerable<double> RollingAverage(this IEnumerable<double> values, int count) 
{ 
    var queue = new Queue<double>(); 
    foreach (var v in values) 
    { 
     queue.Enqueue(v); 
     if (queue.Count == count) 
     { 
      yield return queue.Average(); 
      queue.Dequeue(); 
     } 
    } 
} 

Probablemente se podría mejorar, pero parece que funciona ...

EDIT: he aquí una versión ligeramente mejor (no es necesario enumerar la cola para calcular el promedio):

public static IEnumerable<double> RollingAverage(this IEnumerable<double> values, int count) 
{ 
    var queue = new Queue<double>(); 
    double sum = 0.0; 
    foreach (var v in values) 
    { 
     sum += v; 
     queue.Enqueue(v); 
     if (queue.Count == count) 
     { 
      yield return sum/count; 
      sum -= queue.Dequeue(); 
     } 
    } 
} 

Answer 2

una opción sería hacer un método de extensión que proporciona una "ventana" de laminación se puede utilizar. Esto permitiría que usted escriba su bucle de una manera sencilla:

IEnumerable<IList<T>> CreateRollingWindow(IEnumerable<T> items, int size) 
{ 
    LinkedList<T> list = new LinkedList<T>(); 

    foreach(var item in items) 
    { 
     list.AddLast(item); 
     if (list.Count == size) 
     { 
      yield return list.ToList(); 
      list.RemoveFirst(); 
     } 
    } 
} 

Esto entonces permitirá escribir sus algoritmos simplemente como:

foreach(var window as collection.CreateRollingWindow(5)) 
{ 
    double rollingAverage = window.Average(); // window is IList<T> here 
}