Sum array of arrays (matrix) vertically efficiently/elegantly

I think you are unhappy that there is no native zip function, because that's what your reduce in the map is essentially doing. You'll either have to implement it yourself or import it from a library like Ramda, in order to write elegant code like this:

var verticalSum = x.map(R.zipWith(function(a,b){ return a+b; }));

If you are looking for an efficient solution, there's basically no better way than explicit loops.

arrayOfArrays = [
  [1,2,3,4],
  [5,6,7,8],
  [9,10,11,12]
];

arrayOfArrays.reduce(function(array1, array2) {
  return array1.map(function(value, index) {
    return value + array2[index];
  });
});

For my own benefit, and hopefully the benefit of others, I wanted to explain how the nested reduce/map methods function to perform the vertical summation of an array of equal length arrays. This is the perfectly acceptable version offered by the OP.

The reduce method applies a function against an accumulator and each value of the array from left to right to reduce it to a single value (MDN).

The case of this example, in the the first iteration the first two arrays are passed into the callback function for reduce as array1 and array2. The return value for the callback function is the result of the map method applied to array1.

map returns a new array with the results of calling the provided function on every element of the array. (MDN).

So map iterates each value in array1 and adds it to the value in array2 at the same index position. These results are pushed to a new array which is then returned to the reduce method.

The array of sums that was just returned now becomes the new array1 and reduce invokes its function passing in the new array1 and the next array as the new array2.

This is repeated until we run out of arrays in arrayOfArrays

Starting with:

arrayOfArrays = [
  [1,2,3,4],
  [5,6,7,8],
  [9,10,11,12]
];

The first iteration of reduce passes:

array1 [1,2,3,4]
array2 [5,6,7,8]

To the callback function for reduce. The return value for reduce is a new array derived by using map to add each value of array1 to the value of array2 in the same position:

array1 [1,2,3,4]
array2 [5,6,7,8]
return [6,8,10,12]

This value is returned to the reduce method and becomes the new array1. array1 and next array (array2) are then again passed into the reduce callback function and summed by the map method:

array1 [6,8,10,12]
array2 [9,10,11,12]
return [15,18,21,24]   // returned by map()

You could sum the values at the same index.

Use: array.reduce(sum)

var sum = (r, a) => r.map((b, i) => a[i] + b);

console.log([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]].reduce(sum));

.as-console-wrapper { max-height: 100% !important; top: 0; }