Apply function row/column-wise

[npiccolotto]

Hello,

thanks for the great library, I use it quite often in my work. Something I didn't find in the API and thus copy around my projects is an apply function? Like R's apply or numpy's apply_along_axis.

It seems like a simple function, my implementation is basically

function apply(M, fun, axis = 1) {
  // axis = 0: apply and collapse along cols (= output length is # rows)
  // axis = 1: apply and collapse along rows (= output length is # cols)
  const collapseRows = axis === 1;
  const n = collapseRows ? M.columns : M.rows;
  const result = [];
  for (let i = 0; i < n; i++) {
    const x = collapseRows ? M.getColumn(i) : M.getRow(i);
    result.push(fun(x));
  }
  return Matrix.rowVector(result); // NOTE could also be columnVector depending on `axis`, I just never wanted one...
}

Would this be something that you would consider adding to your library?

[targos]

This seems like a useful feature. Pull request welcome (please add test cases and update matrix.d.ts)!

We suggest the following signature:

class Matrix {
  applyAlongAxis(
    callback: (vector: number[], index: number) => number,
    by: MatrixDimension
  ): Matrix
}

[Dimava]

class MatrixExt extends Matrix {
    mapColumns(fun: (column: number[], rowIndex: number, matrix: this) => number | number[]): Matrix {
        const n = this.columns;
        const result = Array();
        for (let i = 0; i < n; i++) {
            const x = this.getColumn(i)
            result.push(fun(x, i, this));
        }
        if (Array.isArray(result[0])) {
            return new Matrix(result).transpose()
        } else {
            return Matrix.rowVector(result);
        }
    }
}

let m = new MatrixExt([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

console.log(
    m,
    /**
     * Matrix {
     *   [
     *     147      258      369     
     *   ]
     */
    m.mapColumns(
        (row, i, a) => row.reduce((r, x) => r * 10 + x)
    ),
    /**
     * Matrix {
     *  [
     *    1        2        3       
     *    11       22       33      
     *    4        5        6
     *    44       55       66
     *    7        8        9
     *    77       88       99
     *  ]
     */
    m.mapColumns(
        (row, i, a) => row.flatMap(x => [x, x * 11])
    ),
)

Here's implementation of an extended variant

What part of it is technically usable?

[npiccolotto]

Hi, sorry for the late reply, I have actually no idea where the notifications go, if they go somewhere at all.

@Dimava: I like your approach because it's more flexible regarding the resulting matrix dimensions.

@targos: What do you think about it? Should it rather match what exists in other libraries / languages?