C# Pętla przez IEnumerable dla obliczeń, które używa n poprzednich i następnych elementów

Question

Często znajduję się w obiekcie IEnumerable, którego potrzebuję, aby wykonać pętlę, wykonując obliczenia dla każdego elementu, który zależy od n bezpośrednio poprzedzającego i następujące obiekty.

Jednym z typowych przykładów jest obliczenie średnia krocząca, ale inne czasy obliczenie jest bardziej skomplikowane niż to i opiera się na kilku dziedzinach, z każdego z elementów listy

nigdy nie jestem pewien co do najlepszego sposobu uporządkowania moje pętle. Wydajność ma znaczenie, ale ważniejsza jest łatwość konserwacji i czytelność.

• Czasami przekonwertować do listy, a następnie użyć pętli for, aby elementy [i-1], [i], [i + 1], a następnie wykonać moje obliczenia.

• Innym razem zachowuję go jako IEnumerable, ale "buforuję" poprzednią parę elementów, więc nie wykonuję obliczeń dla i dopóki nie dotrę do [i + 1] w pętli foreach .

• Rozważałem również użycie połączonej listy, aby móc korzystać z metod .Poprzednia i .Next.

Jakieś sugestie, która technika byłaby najlepsza w użyciu?

Answer 1

Oto proste wdrożenie:

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(); 
     } 
    } 
} 

To może być prawdopodobnie lepsze, ale wydaje się działać ...

EDIT: tu jest nieznacznie lepsza wersja (nie trzeba wyliczyć kolejka, aby obliczyć średnią):

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

Jedną opcją byłoby wykonanie metody rozszerzenia, która zapewniałoby ruchome "okno", którego można użyć. Pozwoliłoby to napisać pętlę w prosty sposób:

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(); 
     } 
    } 
} 

To pozwól piszesz algorytmy prostu jako:

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