LINQ - returning list of averages based on index in list

Question

So I have a kindda odd scenario that I cannot get my head arround:

I have a outerlist which contains multiple innerlists.
Each innerlist contains multiple DataPoint objects.
Every innerlist contains the same amount of DataPoint objects.
A datapoint has a field called Value which is a double - e.g.:

• Outerlist
  • Innerlist
    • DataPoint(value=2)
    • DataPoint(value=2)
  • Innerlist
    • DataPoint(value=4)
    • DataPoint(value=5)
  • Innerlist
    • DataPoint(value=3)
    • DataPoint(value=5)

So what I wanna do is to "combine" the innerlists into one List where the value of each DataPoint should be the average of the old values, based on its index in the list - in this case:

• List
  • DataPoint(3) - ((2+4+3)/3) = 3
  • DataPoint(4) - ((2+5+5)/3) = 4

Is there any neat linq expression that could perform this kind of stuff (Im betting there are :))?

---

I ended up using the following solution:

var averages = Enumerable.Range(0, outer.First().Count()).Select(i => new DataPoint(outer.Select(l => l[i]).Average(x=>x.Value)));

which outputs IEnumerable, now with average valus - yay!

Answer 1

Start with an extension method to take a slice of the inner lists:

public static IEnumerable<double> Slice(
    this IEnumerable<List<DataPoint>> innerLists,
    int index) {
        foreach(var innerList in innerLists) {
            yield return innerList.DataPoints[index].Value;
        }
    }
}

Then:

var averages = Enumerable.Range(0, count)
                         .Select(index => outerList.InnerLists.Slice(index))
                         .Select(slice => slice.Average());

I am assuming a hierarchy like this:

class DataPoint { public double Value { get; set; } }

class InnerList { public List<DataPoint> DataPoints { get; set; } }

class OuterList { public IEnumerable<InnerList> InnerLists { get; set; } }

but the above idea is obviously adaptable to however exactly you have structured your data.

Answer 2

The key here would be to group the inner list values by their index. Something like this would work:

// Test data
var list = new List<List<double>>() { 
    new List<double> { 2, 2 },
    new List<double> { 4, 5 },
    new List<double> { 3, 5 }
};

// Created groups based on index
var lookup = from inner in list 
             from value in inner.Select((n,idx) => new { n,idx })
             group value by value.idx;

// Calculate averages    
var averagesBasedOnIndex = lookup.Select(g => g.Average(x => x.n)).ToList();

Answer 3

I'm on my iPad, so I havent compiled, but the following should work:

Enumerable.Range(0,outer.First().Length).
   Select(i => outer.Select(l => l[i]).Average());

Answer 4

This is all you need:

var outer = new List<List<List<double>>>();
var l1 = outer.Select(
  x => new List<double> { 
         x.Average(y => y[0]), 
         x.Average(y => y[1]), 
         x.Average(y => y[2])
       });

With a data structure like yours, it would be:

var list = items.Select(x => new List<DataPoint> (
            Enumerable.Range(0,3).Select(z => 
                new DataPoint {
                   Value = x.InnerLists.Average(y => y.DataPoints[z].Value)})
           ));

(Thank you to whomever suggested the Enumerable.Range)