Ideas for additional matrix functions

[joezappie]

I'm working on converting some python code over to a js application using math.js. There's been a few basic matrix functions that I need that I didn't find already in mathjs. I ended up importing my own functions into mathjs, but would love to see if theres any interest in these becoming part of the library.

math.import({
  // Get the number of dimensions in the matrix
  ndim: (matrix) => {
    return math.matrix(matrix).size().valueOf().length;
  },

  // Utility function which takes a list of axes and forces them to be between 0 and ndim (converts negative indices to positive)
  normalizeAxisList: (axis, ndim, options = {}) => {
    // Force into array
    axis = [].concat(axis);

    // Remove duplicates by default
    if (options.allowDuplicates !== true) {
      axis = [...new Set(axis)];
    }

    // Ensure each axis index is 0 <= axis < ndim
    return axis.map((a) => math.normalizeAxisIndex(a, ndim));
  },

  // Utility function to force a single axis to be between 0 and ndim (converts negative indices to positive)
  normalizeAxisIndex: (axis, ndim) => {
    if (Math.abs(axis) >= ndim) {
      throw new Error("Invalid axis: out of bounds");
    }

    if (axis < 0) {
      axis += ndim;
    }

    return axis;
  },

  // Get the shape of the matrix
  shape: (matrix) => {
    if (typeof matrix.valueOf === "function") {
      matrix = matrix.valueOf();
    }

    if (Array.isArray(matrix) === false) {
      return null;
    }

    const rows = matrix.length;
    const cols = matrix.map((col) => {
      return math.shape(col);
    });

    const reducedCols = [].concat(
      cols.reduce((max, col) => (col && col[1] > max ? col[1] : max))
    );

    return [rows, ...reducedCols].filter((col) => col);
  },

  // Add an additional dimension to the given axis
  expandDims: (matrix, axis = 0) => {
    // Force into matrix
    matrix = math.matrix(matrix);

    // Force into array
    axis = [].concat(axis);

    // New ndim size
    let ndimOut = math.ndim(matrix) + axis.length;

    axis = math.normalizeAxisList(axis, ndimOut);

    let originalAxis = 0;
    let originalShape = math.shape(matrix);

    let newShape = math.range(0, ndimOut).map((a) => {
      if (axis.includes(a)) {
        return 1;
      }
      return originalShape[originalAxis++];
    });

    return math.reshape(matrix, newShape);
  },

  // Generate a list of evenly spaced points between two values
  linspace: (start, end, options) => {
    options = { num: 50, endpoint: true, ...options };
    if (start === end) {
      throw new Error("Value Error: start and end cannot be equal");
    }

    let { endpoint, num } = options;

    // Force number to be integer
    num = Math.floor(num);

    // Return end value if num is less than 0
    if (num <= 1) {
      return [end];
    }

    const numSteps = endpoint ? num - 1 : num;
    const step = (end - start) / numSteps;
    return Array.from({ length: num }, (_, i) => start + step * i);
  },
});

A lot of this is inspired by numpy or matlab. The normalize axis functions are just utility functions used for expandDims. Tensorflow.js also implements these as they try to closely match numpy but I already use mathjs for other things and don't want to switch so I'd love to help add more functionality to this library.

Open to submitting a PR, but wanted to check if any of this is worth my time and if mathjs is open to adding any of these and where in the API they should go.

Also curious if theres any easier ways to do any of these with the existing mathjs api. I'm no math or math.js expert so some of this might be possible with less code relying more on existing functionality.

[dvd101x]

Hi, this might be somewhat in line with #2702.

A few pointers in the meantime you get a more educated response:

• some of the type checking might be omitted by using typed and even could help with the automatic type conversion between array and matrix
• linspace might benefit from range

[josdejong]

Thanks for your suggestions Joe, and for sharing your current implementation for those utility functions!