mathjs 14.1.0 → 14.2.0

package/lib/esm/function/matrix/matrixFromFunction.js

@@ -9,8 +9,10 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
   } = _ref;
   /**
    * Create a matrix by evaluating a generating function at each index.
-   * The simplest overload returns a multi-dimensional array as long as `size` is an array.
-   * Passing `size` as a Matrix or specifying a `format` will result in returning a Matrix.
+   * The simplest overload returns a multi-dimensional array as long as `size`
+   * is an array.
+   * Passing `size` as a Matrix or specifying a `format` will result in
+   * returning a Matrix.
    *
    * Syntax:
    *
@@ -20,6 +22,37 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
    *    math.matrixFromFunction(size, format, fn)
    *    math.matrixFromFunction(size, format, datatype, fn)
    *
+   * Where:
+   *
+   *    - `size: (number[] | Matrix)`
+   *      A vector giving the extent of the array to be created in each
+   *      dimension. If size has one entry, a vector is created; if it
+   *      has two, a rectangular array/Matrix is created; if three, a
+   *      three-dimensional array/Matrix is created; and so on.
+   *    - `fn: (index: number[]) => MathType`
+   *      The callback function that will generate the entries of the
+   *      matrix. It is called in turn with the index of each entry of
+   *      the matrix. The index is always an ordinary array of numbers
+   *      with the same length as _size_. So for vectors, you will get
+   *      indices like `[0]` or `[1]`, whereas for matrices, you will
+   *      get indices like `[2, 0]` or `[1,3]`. The return value may
+   *      be any type that can go in an array or Matrix entry, although
+   *      if you supply the _datatype_ argument, you must yourself ensure
+   *      the type of the return value matches. Note that currently,
+   *      your callback _fn_ will receive 0-based indices for the matrix
+   *      entries, regardless of whether matrixFromFunction is invoked
+   *      directly from JavaScript or via the mathjs expression language.
+   *    - `format: 'dense'|'sparse'`
+   *      Specifies the storage format for the resulting Matrix. Note that
+   *      if this argument is given, the return value will always be a
+   *      Matrix (rather than possibly an Array).
+   *    - `datatype: string`
+   *      Specifies the data type of entries of the new matrix. If given,
+   *      it should be the name of a data type that mathjs supports, as
+   *      returned by the math.typeOf function. It is up to the caller
+   *      to make certain that all values returned by _fn_ are consistent
+   *      with this datatype if specified.
+   *
    * Examples:
    *
    *    math.matrixFromFunction([3,3], i => i[0] - i[1]) // an antisymmetric matrix
@@ -28,7 +61,7 @@ export var createMatrixFromFunction = /* #__PURE__ */factory(name, dependencies,
    *
    * See also:
    *
-   *    matrix, zeros
+   *    matrix, typeOf, zeros
    *
    * @param {Array | Matrix} size   The size of the matrix to be created
    * @param {function} fn           Callback function invoked for every entry in the matrix

package/lib/esm/function/matrix/range.js

@@ -35,36 +35,48 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * - `str: string`
    *   A string 'start:end' or 'start:step:end'
-   * - `start: {number | BigNumber | Unit}`
+   * - `start: {number | bigint | BigNumber | Fraction | Unit}`
    *   Start of the range
-   * - `end: number | BigNumber | Unit`
+   * - `end: number | bigint | BigNumber | Fraction | Unit`
    *   End of the range, excluded by default, included when parameter includeEnd=true
-   * - `step: number | BigNumber | Unit`
+   * - `step: number | bigint | BigNumber | Fraction | Unit`
    *   Step size. Default value is 1.
    * - `includeEnd: boolean`
    *   Option to specify whether to include the end or not. False by default.
    *
+   * Note that the return type of the range is taken from the type of
+   * the start/end. If only one these is a built-in `number` type, it will
+   * be promoted to the type of the other endpoint. However, in the case of
+   * Unit values, both endpoints must have compatible units, and the return
+   * value will have compatible units as well.
+   *
    * Examples:
    *
    *     math.range(2, 6)        // [2, 3, 4, 5]
    *     math.range(2, -3, -1)   // [2, 1, 0, -1, -2]
    *     math.range('2:1:6')     // [2, 3, 4, 5]
    *     math.range(2, 6, true)  // [2, 3, 4, 5, 6]
+   *     math.range(2, math.fraction(8,3), math.fraction(1,3)) // [fraction(2), fraction(7,3)]
    *     math.range(math.unit(2, 'm'), math.unit(-3, 'm'), math.unit(-1, 'm')) // [2 m, 1 m, 0 m , -1 m, -2 m]
    *
    * See also:
    *
    *     ones, zeros, size, subset
    *
-   * @param {*} args   Parameters describing the ranges `start`, `end`, and optional `step`.
+   * @param {*} args   Parameters describing the range's `start`, `end`, and optional `step`.
    * @return {Array | Matrix} range
    */
   return typed(name, {
     // TODO: simplify signatures when typed-function supports default values and optional arguments
 
-    // TODO: a number or boolean should not be converted to string here
     string: _strRange,
     'string, boolean': _strRange,
+    number: function number(oops) {
+      throw new TypeError("Too few arguments to function range(): ".concat(oops));
+    },
+    boolean: function boolean(oops) {
+      throw new TypeError("Unexpected type of argument 1 to function range(): ".concat(oops, ", number|bigint|BigNumber|Fraction"));
+    },
     'number, number': function number_number(start, end) {
       return _out(_range(start, end, 1, false));
     },
@@ -77,6 +89,31 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     'number, number, number, boolean': function number_number_number_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    // Handle bigints; if either limit is bigint, range should be too
+    'bigint, bigint|number': function bigint_bigintNumber(start, end) {
+      return _out(_range(start, end, 1n, false));
+    },
+    'number, bigint': function number_bigint(start, end) {
+      return _out(_range(BigInt(start), end, 1n, false));
+    },
+    'bigint, bigint|number, bigint|number': function bigint_bigintNumber_bigintNumber(start, end, step) {
+      return _out(_range(start, end, BigInt(step), false));
+    },
+    'number, bigint, bigint|number': function number_bigint_bigintNumber(start, end, step) {
+      return _out(_range(BigInt(start), end, BigInt(step), false));
+    },
+    'bigint, bigint|number, boolean': function bigint_bigintNumber_boolean(start, end, includeEnd) {
+      return _out(_range(start, end, 1n, includeEnd));
+    },
+    'number, bigint, boolean': function number_bigint_boolean(start, end, includeEnd) {
+      return _out(_range(BigInt(start), end, 1n, includeEnd));
+    },
+    'bigint, bigint|number, bigint|number, boolean': function bigint_bigintNumber_bigintNumber_boolean(start, end, step, includeEnd) {
+      return _out(_range(start, end, BigInt(step), includeEnd));
+    },
+    'number, bigint, bigint|number, boolean': function number_bigint_bigintNumber_boolean(start, end, step, includeEnd) {
+      return _out(_range(BigInt(start), end, BigInt(step), includeEnd));
+    },
     'BigNumber, BigNumber': function BigNumber_BigNumber(start, end) {
       var BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), false));
@@ -91,6 +128,18 @@ export var createRange = /* #__PURE__ */factory(name, dependencies, _ref => {
     'BigNumber, BigNumber, BigNumber, boolean': function BigNumber_BigNumber_BigNumber_boolean(start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
+    'Fraction, Fraction': function Fraction_Fraction(start, end) {
+      return _out(_range(start, end, 1, false));
+    },
+    'Fraction, Fraction, Fraction': function Fraction_Fraction_Fraction(start, end, step) {
+      return _out(_range(start, end, step, false));
+    },
+    'Fraction, Fraction, boolean': function Fraction_Fraction_boolean(start, end, includeEnd) {
+      return _out(_range(start, end, 1, includeEnd));
+    },
+    'Fraction, Fraction, Fraction, boolean': function Fraction_Fraction_Fraction_boolean(start, end, step, includeEnd) {
+      return _out(_range(start, end, step, includeEnd));
+    },
     'Unit, Unit, Unit': function Unit_Unit_Unit(start, end, step) {
       return _out(_range(start, end, step, false));
     },

package/lib/esm/function/statistics/quantileSeq.js

@@ -1,9 +1,8 @@
 import { isNumber } from '../../utils/is.js';
 import { flatten } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
-import { createApply } from '../matrix/apply.js';
 var name = 'quantileSeq';
-var dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+var dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger', 'mapSlices'];
 export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -17,13 +16,9 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
     isInteger,
     smaller,
     smallerEq,
-    larger
+    larger,
+    mapSlices
   } = _ref;
-  var apply = createApply({
-    typed,
-    isInteger
-  });
-
   /**
    * Compute the prob order quantile of a matrix or a list with values.
    * The sequence is sorted and the middle value is returned.
@@ -69,7 +64,7 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref =
     'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection)
   });
   function _quantileSeqDim(data, prob, sorted, dim, fn) {
-    return apply(data, dim, x => fn(x, prob, sorted));
+    return mapSlices(data, dim, x => fn(x, prob, sorted));
   }
   function _quantileSeqProbNumber(data, probOrN, sorted) {
     var probArr;

package/lib/esm/function/statistics/variance.js

@@ -4,7 +4,7 @@ import { factory } from '../../utils/factory.js';
 import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var DEFAULT_NORMALIZATION = 'unbiased';
 var name = 'variance';
-var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
+var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'mapSlices', 'isNaN'];
 export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -12,7 +12,7 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
     subtract,
     multiply,
     divide,
-    apply,
+    mapSlices,
     isNaN
   } = _ref;
   /**
@@ -145,7 +145,7 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (array.length === 0) {
         throw new SyntaxError('Function variance requires one or more parameters (0 provided)');
       }
-      return apply(array, dim, x => _var(x, normalization));
+      return mapSlices(array, dim, x => _var(x, normalization));
     } catch (err) {
       throw improveErrorMessage(err, 'variance');
     }

package/lib/esm/function/string/hex.js

@@ -11,7 +11,7 @@ var dependencies = ['typed', 'format'];
  *
  * Examples:
  *
- *    math.hex(240) // returns "0xF0"
+ *    math.hex(240) // returns "0xf0"
  *
  * See also:
  *

package/lib/esm/function/trigonometry/acoth.js

@@ -22,7 +22,7 @@ export var createAcoth = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *    math.acoth(0.5)       // returns 0.8047189562170503
+   *    math.acoth(0.5)     // returns 0.5493061443340548 - 1.5707963267948966i
    *
    * See also:
    *

package/lib/esm/function/trigonometry/acsc.js

@@ -23,7 +23,7 @@ export var createAcsc = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.acsc(2)             // returns 0.5235987755982989
    *    math.acsc(0.5)           // returns Complex 1.5707963267948966 -1.3169578969248166i
-   *    math.acsc(math.csc(1.5)) // returns number ~1.5
+   *    math.acsc(math.csc(1.5)) // returns number 1.5
    *
    * See also:
    *

package/lib/esm/function/trigonometry/asin.js

@@ -20,7 +20,7 @@ export var createAsin = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Examples:
    *
    *    math.asin(0.5)           // returns number 0.5235987755982989
-   *    math.asin(math.sin(1.5)) // returns number ~1.5
+   *    math.asin(math.sin(1.5)) // returns number 1.5
    *
    *    math.asin(2)             // returns Complex 1.5707963267948966 -1.3169578969248166i
    *

package/lib/esm/function/trigonometry/atan2.js

@@ -56,9 +56,10 @@ export var createAtan2 = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.atan2(2, 2) / math.pi       // returns number 0.25
    *
-   *    const angle = math.unit(60, 'deg') // returns Unit 60 deg
+   *    const angle = math.unit(60, 'deg')
    *    const x = math.cos(angle)
    *    const y = math.sin(angle)
+   *    math.atan2(y, x) * 180 / math.pi  // returns 60
    *
    *    math.atan(2)             // returns number 1.1071487177940904
    *

package/lib/esm/function/trigonometry/cos.js

@@ -28,7 +28,7 @@ export var createCos = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    math.cos(math.unit(60, 'deg'))   // returns number  0.5
    *
    *    const angle = 0.2
-   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number 1
    *
    * See also:
    *

package/lib/esm/function/trigonometry/sin.js

@@ -28,7 +28,7 @@ export var createSin = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    math.sin(math.unit(30, 'deg'))   // returns number 0.5
    *
    *    const angle = 0.2
-   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number 1
    *
    * See also:
    *

package/lib/esm/type/matrix/MatrixIndex.js

@@ -42,6 +42,7 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       var arg = arguments[i];
       var argIsArray = isArray(arg);
       var argIsMatrix = isMatrix(arg);
+      var argType = typeof arg;
       var sourceSize = null;
       if (isRange(arg)) {
         this._dimensions.push(arg);
@@ -63,13 +64,15 @@ export var createIndexClass = /* #__PURE__ */factory(name, dependencies, _ref =>
         if (size.length !== 1 || size[0] !== 1 || sourceSize !== null) {
           this._isScalar = false;
         }
-      } else if (typeof arg === 'number') {
+      } else if (argType === 'number') {
         this._dimensions.push(_createImmutableMatrix([arg]));
-      } else if (typeof arg === 'string') {
+      } else if (argType === 'bigint') {
+        this._dimensions.push(_createImmutableMatrix([Number(arg)]));
+      } else if (argType === 'string') {
         // object property (arguments.count should be 1)
         this._dimensions.push(arg);
       } else {
-        throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
+        throw new TypeError('Dimension must be an Array, Matrix, number, bigint, string, or Range');
       }
       this._sourceSize.push(sourceSize);
       // TODO: implement support for wildcard '*'

package/lib/esm/type/matrix/Range.js

@@ -1,18 +1,25 @@
-import { isBigNumber } from '../../utils/is.js';
+import { isBigInt, isBigNumber } from '../../utils/is.js';
 import { format, sign } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 var name = 'Range';
 var dependencies = [];
 export var createRangeClass = /* #__PURE__ */factory(name, dependencies, () => {
   /**
-   * Create a range. A range has a start, step, and end, and contains functions
-   * to iterate over the range.
+   * Create a range of numbers. A range has a start, step, and end,
+   * and contains functions to iterate over the range.
    *
    * A range can be constructed as:
    *
    *     const range = new Range(start, end)
    *     const range = new Range(start, end, step)
    *
+   * Note that the endpoints and step may be specified with other numeric
+   * types such as bigint or BigNumber, but they will be demoted to the
+   * built-in `number` type and the Range will only contain numbers. The
+   * rationale for this demotion is that Range objects are primarily used
+   * for indexing Matrix objects, and Matrix objects may only be indexed
+   * with `number`s.
+   *
    * To get the result of the range:
    *     range.forEach(function (x) {
    *         console.log(x)
@@ -45,22 +52,22 @@ export var createRangeClass = /* #__PURE__ */factory(name, dependencies, () => {
     if (hasStart) {
       if (isBigNumber(start)) {
         start = start.toNumber();
-      } else if (typeof start !== 'number') {
-        throw new TypeError('Parameter start must be a number');
+      } else if (typeof start !== 'number' && !isBigInt(start)) {
+        throw new TypeError('Parameter start must be a number or bigint');
       }
     }
     if (hasEnd) {
       if (isBigNumber(end)) {
         end = end.toNumber();
-      } else if (typeof end !== 'number') {
-        throw new TypeError('Parameter end must be a number');
+      } else if (typeof end !== 'number' && !isBigInt(end)) {
+        throw new TypeError('Parameter end must be a number or bigint');
       }
     }
     if (hasStep) {
       if (isBigNumber(step)) {
         step = step.toNumber();
-      } else if (typeof step !== 'number') {
-        throw new TypeError('Parameter step must be a number');
+      } else if (typeof step !== 'number' && !isBigInt(step)) {
+        throw new TypeError('Parameter step must be a number or bigint');
       }
     }
     this.start = hasStart ? parseFloat(start) : 0;

package/lib/esm/utils/factory.js

@@ -20,8 +20,11 @@ import { pickShallow } from './object.js';
  * @param {string} name           Name of the function to be created
  * @param {string[]} dependencies The names of all required dependencies
  * @param {function} create       Callback function called with an object with all dependencies
- * @param {Object} [meta]         Optional object with meta information that will be attached
- *                                to the created factory function as property `meta`.
+ * @param {Object} [meta]
+ *     Optional object with meta information that will be attached
+ *     to the created factory function as property `meta`. For explanation
+ *     of what meta properties can be specified and what they mean, see
+ *     docs/core/extension.md.
  * @returns {function}
  */
 export function factory(name, dependencies, create, meta) {

package/lib/esm/utils/snapshot.js

@@ -101,16 +101,22 @@ export function createSnapshotFromFactories(factories) {
   var allClasses = {};
   var allNodeClasses = {};
   Object.keys(factories).forEach(factoryName => {
+    var _factory$meta$formerl, _factory$meta;
     var factory = factories[factoryName];
     var name = factory.fn;
     var isTransformFunction = factory.meta && factory.meta.isTransformFunction;
     var isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'function';
     var dependenciesName = factory.fn + (isTransformFunction ? 'Transform' : '') + 'Dependencies';
+    var former = (_factory$meta$formerl = (_factory$meta = factory.meta) === null || _factory$meta === void 0 ? void 0 : _factory$meta.formerly) !== null && _factory$meta$formerl !== void 0 ? _factory$meta$formerl : '';
     allFactoryFunctions[factoryName] = 'function';
     allFunctionsConstantsClasses[name] = validateTypeOf(math[name]);
+    if (former) {
+      allFunctionsConstantsClasses[former] = allFunctionsConstantsClasses[name];
+    }
     allDependencyCollections[dependenciesName] = 'Object';
     if (isTransformFunction) {
       allTransformFunctions[name] = 'function';
+      if (former) allTransformFunctions[former] = 'function';
     }
     if (isClass) {
       if (endsWith(name, 'Node')) {
@@ -120,6 +126,7 @@ export function createSnapshotFromFactories(factories) {
       }
     } else {
       allFunctionsConstants[name] = validateTypeOf(math[name]);
+      if (former) allFunctionsConstants[former] = allFunctionsConstants[name];
     }
   });
   var embeddedDocs = {};
@@ -131,7 +138,7 @@ export function createSnapshotFromFactories(factories) {
       embeddedDocs[name] = 'Object';
     }
   });
-  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
   var allTypeChecks = {};
   Object.keys(allIsFunctions).forEach(name => {
     if (name.indexOf('is') === 0) {

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.1.0';
+export var version = '14.2.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "14.1.0",
+  "version": "14.2.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",

package/types/index.d.ts

@@ -21,6 +21,12 @@ export type MathCollection<T = MathGeneric> = MathArray<T> | Matrix<T>
 export type MathType = MathScalarType | MathCollection
 export type MathExpression = string | string[] | MathCollection
 
+// add type for Matrix Callback Function and Matrix Storage Format
+export type MatrixStorageFormat = 'dense' | 'sparse'
+export type MatrixFromFunctionCallback<T extends MathScalarType> = (
+  index: number[]
+) => T
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type FactoryFunction<T> = (scope: any) => T
 
@@ -743,7 +749,7 @@ export interface MathJsInstance extends MathJsFactory {
    * @param format The Matrix storage format
    * @returns The created Matrix
    */
-  matrix(format?: 'sparse' | 'dense'): Matrix
+  matrix(format?: MatrixStorageFormat): Matrix
   /**
    * @param data A multi dimensional array
    * @param format The Matrix storage format
@@ -752,12 +758,12 @@ export interface MathJsInstance extends MathJsFactory {
    */
   matrix(
     data: MathCollection | string[],
-    format?: 'sparse' | 'dense',
+    format?: MatrixStorageFormat,
     dataType?: string
   ): Matrix
   matrix<T extends MathScalarType>(
     data: MathCollection<T>,
-    format?: 'sparse' | 'dense',
+    format?: MatrixStorageFormat,
     dataType?: string
   ): Matrix<T>
 
@@ -1322,6 +1328,58 @@ export interface MathJsInstance extends MathJsFactory {
   hypot<T extends number | BigNumber>(...args: T[]): T
   hypot<T extends number | BigNumber>(args: T[]): T
 
+  /**
+   * Create a dense matrix from vectors as individual rows. If you pass column vectors, they will be transposed (but not conjugated!)
+   * @param rows - a multi-dimensional number array or matrix
+   */
+  matrixFromRows(...rows: Matrix[]): Matrix
+  matrixFromRows<T extends MathScalarType>(
+    ...rows: (T[] | [T][] | Matrix)[]
+  ): T[][]
+
+  /**
+   * Create a dense matrix from vectors as individual columns. If you pass row vectors, they will be transposed (but not conjugated!)
+   * @param cols - a multi-dimensional number array or matrix
+   */
+  matrixFromColumns(...cols: Matrix[]): Matrix
+  matrixFromColumns<T extends MathScalarType>(
+    ...cols: (T[] | [T][] | Matrix)[]
+  ): T[][]
+  /**
+   * Create a matrix by evaluating a generating function at each index. The simplest overload returns a multi-dimensional array as long as size is an array. Passing size as a Matrix or specifying a format will result in returning a Matrix.
+   * @param size - the size of the matrix to be created
+   * @param fn - Callback function invoked for every entry in the matrix
+   * @param format - The Matrix storage format, either 'dense' or 'sparse'
+   * @param datatype - Type of the values
+   */
+  matrixFromFunction<T extends MathScalarType>(
+    size: [number],
+    fn: MatrixFromFunctionCallback<T>
+  ): T[]
+  matrixFromFunction<T extends MathScalarType>(
+    size: [number, number],
+    fn: MatrixFromFunctionCallback<T>
+  ): T[][]
+  matrixFromFunction<T extends MathScalarType>(
+    size: number[],
+    fn: MatrixFromFunctionCallback<T>
+  ): MathArray<T>
+  matrixFromFunction(
+    size: Matrix<number>,
+    fn: MatrixFromFunctionCallback<MathScalarType>
+  ): Matrix
+  matrixFromFunction(
+    size: number[] | Matrix<number>,
+    fn: MatrixFromFunctionCallback<MathScalarType>,
+    format: MatrixStorageFormat,
+    datatype?: string
+  ): Matrix
+  matrixFromFunction(
+    size: number[] | Matrix<number>,
+    format: MatrixStorageFormat,
+    fn: MatrixFromFunctionCallback<MathScalarType>,
+    datatype?: string
+  ): Matrix
   /**
    * Calculate the least common multiple for two or more values or arrays.
    * lcm is defined as: lcm(a, b) = abs(a * b) / gcd(a, b) For matrices,
@@ -1805,11 +1863,15 @@ export interface MathJsInstance extends MathJsFactory {
    * array or 1-d matrix as an input and return a number.
    * @returns The residual matrix with the function applied over some dimension.
    */
-  apply<T extends MathCollection>(
+  mapSlices<T extends MathCollection>(
     array: T,
     dim: number,
     callback: (array: MathCollection) => number
   ): T
+  /**
+   * @deprecated backwards-compatibility old name of mapSlices
+   */
+  apply: MathJsInstance['mapSlices']
 
   /**
    * Concatenate two or more matrices. dim: number is a zero-based
@@ -3705,7 +3767,7 @@ export const {
   unaryMinusDependencies,
   unaryPlusDependencies,
   absDependencies,
-  applyDependencies,
+  mapSlicesDependencies,
   addScalarDependencies,
   cbrtDependencies,
   ceilDependencies,
@@ -3984,7 +4046,7 @@ export const {
   vacuumImpedanceDependencies,
   weakMixingAngleDependencies,
   wienDisplacementDependencies,
-  applyTransformDependencies,
+  mapSlicesTransformDependencies,
   columnTransformDependencies,
   filterTransformDependencies,
   forEachTransformDependencies,
@@ -4010,10 +4072,6 @@ export interface Matrix<T = MathGeneric> {
   density(): number
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   subset(index: Index, replacement?: any, defaultValue?: any): Matrix
-  apply(
-    dim: number,
-    callback: (array: MathCollection) => number
-  ): MathCollection
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   get(index: number[]): any
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -4996,11 +5054,15 @@ export interface MathJsChain<TValue> {
    * array or 1-d matrix as an input and return a number.
    * @returns The residual matrix with the function applied over some dimension.
    */
-  apply<T extends MathCollection>(
+  mapSlices<T extends MathCollection>(
     this: MathJsChain<T>,
     dim: number,
     callback: (array: Array<MathType> | Matrix) => number
   ): MathJsChain<T>
+  /**
+   * @deprecated backwards-compatibility old name of mapSlices
+   **/
+  apply: MathJsChain<TValue>['mapSlices']
 
   /**
    * Calculate the cubic root of a value. For matrices, the function is
@@ -7162,7 +7224,8 @@ export const {
   xor,
 
   // matrix functions
-  apply,
+  mapSlices,
+  apply, // @deprecated prior name of mapSlices
   concat,
   cross,
   det,