Operations with Matrix V2

operationsWithMatrixV2.js

const plus = (a = 0) => (b = 0) => a + b
const times = (a = 0) => (b = 0) => a * b
const minus = (a = 0) => (b = 0) => a - b
const obelus = (a = 1) => (b = 1) => a / b

const applyVerticalOperation = (fn) => (acc, cur) => acc.map((value, index) => fn(cur[index])(value))
const applyHorizontalOrDiagonalOperation = (fn) => (list) => list.reduce((acc, cur) => fn(acc)(cur))

const solveVerticalMatrix = (list) => (fn) => list.reduce(applyVerticalOperation(fn))
const solveHorizontalMatrix = (list) => (fn) => list.map(applyHorizontalOrDiagonalOperation(fn))
const solveDiagonalLeftMatrix = (list) => (fn) => applyHorizontalOrDiagonalOperation(fn)(list.map((num, index) => num[index]))
const solveDiagonalRigthMatrix = (list) => (fn) => applyHorizontalOrDiagonalOperation(fn)(list.reverse().map((num, index) => num[index]))

const array = [
   [1,2,3,4,5,6],
   [6,5,4,3,2,1],
   [1,2,3,4,5,6],
   [6,5,4,3,2,1],
   [1,2,3,4,5,6],
   [6,5,4,3,2,1],
]

const plusVerticalMatrix = solveVerticalMatrix(array)(plus)
const timesVerticalMatrix = solveVerticalMatrix(array)(times)
const minusVerticalMatrix = solveVerticalMatrix(array)(minus)
const obelusVerticalMatrix = solveVerticalMatrix(array)(obelus)

const plusHorizontalMatrix = solveHorizontalMatrix(array)(plus)
const timesHorizontalMatrix = solveHorizontalMatrix(array)(times)
const minusHorizontalMatrix = solveHorizontalMatrix(array)(minus)
const obelusHorizontalMatrix = solveHorizontalMatrix(array)(obelus)

const plusDiagonalLeftMatrix = solveDiagonalLeftMatrix(array)(plus)
const timesDiagonalLeftMatrix = solveDiagonalLeftMatrix(array)(times)
const minusDiagonalLeftMatrix = solveDiagonalLeftMatrix(array)(minus)
const obelusDiagonalLeftMatrix = solveDiagonalLeftMatrix(array)(obelus)

const plusDiagonalRigthMatrix = solveDiagonalRigthMatrix(array)(plus)
const timesDiagonalRigthMatrix = solveDiagonalRigthMatrix(array)(times)
const minusDiagonalRigthMatrix = solveDiagonalRigthMatrix(array)(minus)
const obelusDiagonalRigthMatrix = solveDiagonalRigthMatrix(array)(obelus)

console.log(plusVerticalMatrix,   // [ 21, 21, 21, 21, 21, 21 ]
            timesVerticalMatrix,  // [ 216, 1000, 1728, 1728, 1000, 216 ]
            minusVerticalMatrix,  // [ -15, -9, -3, 3, 9, 15 ]
            obelusVerticalMatrix) // [ 0.004629629629629629, 0.064, 0.421875, 2.3703703703703702, 15.625, 216 ]

console.log(plusHorizontalMatrix,   // [ 21, 21, 21, 21, 21, 21 ]
            timesHorizontalMatrix,  // [ 720, 720, 720, 720, 720, 720 ]
            minusHorizontalMatrix,  // [ -19, -9, -19, -9, -19, -9 ]
            obelusHorizontalMatrix ) // [ 0.001388888888888889, 0.049999999999999996, 0.001388888888888889, 0.049999999999999996, 0.001388888888888889, 0.049999999999999996 ]

console.log(plusDiagonalLeftMatrix,   // 18
            timesDiagonalLeftMatrix,  // 225
            minusDiagonalLeftMatrix,  // -16
            obelusDiagonalLeftMatrix) // 0.0044444444444444444

console.log(plusDiagonalRigthMatrix,   // 24
            timesDiagonalRigthMatrix,  // 225
            minusDiagonalRigthMatrix,  // -12
            obelusDiagonalRigthMatrix) // 0.0044444444444444444