CODEWITHSUNDEEP
linqplinq
Chili Manku
Chili Manku

Reputation: 33

Two dimensional array sum in C#/Linq

I have a two dimensional array of integers. I would like to write an optimized and fast code to sum all the columns of the two dimensional array.

Any thoughts how I might be able to do this using LINQ/PLINQ/TASK parallelization ?

Ex:

private int[,] m_indexes = new int[6,4]  { {367, 40, 74, 15},
                                           {535, 226, 74, 15}, 
                                           {368, 313, 74, 15},
                                           {197, 316, 74, 15}, 
                                           {27, 226, 74, 15},
                                           {194, 41, 74, 15} };

Upvotes: 2

Views: 5622

Answers (3)

driis
driis

Reputation: 164291

Straightforward LINQ way:

var columnSums = m_indexes.OfType<int>().Select((x,i) => new { x, col = i % m_indexes.GetLength(1) } )
    .GroupBy(x => x.col)
    .Select(x => new { Column = x.Key, Sum = x.Sum(g => g.x) });

It might not be worth it to parallelize. If you need to access the array by index, you spend some cycles on bounds checking, so, as always with performance, do measure it.

Upvotes: 1

Y.A.P.
Y.A.P.

Reputation: 538

Or maybe without for's :

List<List<int>> m_indexes = new List<List<int>>()  { new List<int>(){367, 40, 74, 15},
new List<int>(){535, 226, 74, 15}, 
new List<int>(){368, 313, 74, 15},
new List<int>(){197, 316, 74, 15}, 
new List<int>(){27, 226, 74, 15},
new List<int>(){194, 41, 74, 15} };

var res = m_indexes.Select(x => x.Sum()).Sum();

Upvotes: 1

jason
jason

Reputation: 241611

The simplest parallel implementation:

 int[,] m_indexes = new int[6, 4]  { {367, 40, 74, 15},
                                     {535, 226, 74, 15}, 
                                     {368, 313, 74, 15},
                                     {197, 316, 74, 15}, 
                                     {27, 226, 74, 15},
                                     {194, 41, 74, 15} };
 var columns  = Enumerable.Range(0, 4);
 int[] sums = new int[4];
 Parallel.ForEach(columns, column => {
     int sum = 0;
     for (int i = 0; i < 6; i++) {
         sum += m_indexes[i, column];
     }
            sums[column] = sum;
 });

This code can obviously be "generalized" (use m_indexes.GetLength(0) and m_indexes.GetLength(1)).

LINQ:

var sums = columns.Select(
    column => {
        int sum = 0;
        for (int i = 0; i < 6; i++) {
            sum += m_indexes[i, column];
         } return sum; 
    }
).ToArray();

Be sure to profile on real-world data here if you truly need to optimize for performance here.

Also, if you truly care about optimizing for performance, try to load up your array so that you summing across rows. You'll get better locality for cache performance that way.

Upvotes: 6

Related Questions