mathjs 14.0.1 → 14.2.0

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/bigint.js

@@ -0,0 +1,27 @@
+/**
+ * Build a bigint logarithm function from a number logarithm,
+ * still returning a number. The idea is that 15 hexadecimal digits
+ * (60 bits) saturates the mantissa of the log, and each additional hex
+ * digit effectively just adds the log of 16 to the resulting value. So
+ * convert the most significant 15 hex digits to a number and take its
+ * log, and then add the log of 16 for each additional hex digit that
+ * was in the bigint.
+ * For negative numbers (complex logarithms), following the bignum
+ * implementation, it just downgrades to number and uses the complex result.
+ * @param {number} log16  the log of 16
+ * @param {(number) -> number} numberLog  the logarithm function for numbers
+ * @param {ConfigurationObject} config  the mathjs configuration
+ * @param {(number) -> Complex} cplx  the associated Complex log
+ * @returns {(bigint) -> number}   the corresponding logarithm for bigints
+ */
+export function promoteLogarithm(log16, numberLog, config, cplx) {
+  return function (b) {
+    if (b > 0 || config.predictable) {
+      if (b <= 0) return NaN;
+      var s = b.toString(16);
+      var s15 = s.substring(0, 15);
+      return log16 * (s.length - s15.length) + numberLog(Number('0x' + s15));
+    }
+    return cplx(b.toNumber());
+  };
+}

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/number.js

@@ -16,16 +16,6 @@ export function isInteger(value) {
   return isFinite(value) ? value === Math.round(value) : false;
 }
 
-/**
- * Check if a string contains an integer
- * @param {string} str
- * @return {boolean} isInteger
- */
-export function isIntegerStr(str) {
-  // regex matching strings like "123" and "-123"
-  return /^-?\d+$/.test(str);
-}
-
 /**
  * Ensure the number type is compatible with the provided value.
  * If not, return 'number' instead.
@@ -45,8 +35,12 @@ export function isIntegerStr(str) {
  * @returns {'number' | 'BigNumber' | 'bigint' | 'Fraction'}
  */
 export function safeNumberType(numberStr, config) {
-  if (config.number === 'bigint' && !isIntegerStr(numberStr)) {
-    return config.numberFallback;
+  if (config.number === 'bigint') {
+    try {
+      BigInt(numberStr);
+    } catch (_unused) {
+      return config.numberFallback;
+    }
   }
   return config.number;
 }
@@ -610,11 +604,6 @@ export function digits(value) {
   .length;
 }
 
-/**
- * Minimum number added to one that makes the result different than one
- */
-export var DBL_EPSILON = Number.EPSILON || 2.2204460492503130808472633361816E-16;
-
 /**
  * Compares two floating point numbers.
  * @param {number} a - First value to compare

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.0.1';
+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.0.1",
+  "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",
@@ -26,6 +26,7 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.25.7",
+    "@lambdatest/node-tunnel": "^4.0.8",
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -44,13 +45,13 @@
     "@babel/register": "7.25.9",
     "@types/assert": "1.5.11",
     "@types/mocha": "10.0.10",
-    "@typescript-eslint/eslint-plugin": "8.18.0",
-    "@typescript-eslint/parser": "8.18.0",
+    "@typescript-eslint/eslint-plugin": "8.21.0",
+    "@typescript-eslint/parser": "8.21.0",
     "assert": "2.1.0",
     "babel-loader": "9.2.1",
     "c8": "10.1.3",
     "codecov": "3.8.3",
-    "core-js": "3.39.0",
+    "core-js": "3.40.0",
     "del": "8.0.0",
     "dtslint": "4.2.1",
     "eigen": "0.2.2",
@@ -60,24 +61,25 @@
     "eslint-plugin-import": "2.31.0",
     "eslint-plugin-mocha": "10.5.0",
     "eslint-plugin-n": "16.6.2",
-    "eslint-plugin-prettier": "5.2.1",
+    "eslint-plugin-prettier": "5.2.3",
     "eslint-plugin-promise": "6.6.0",
     "expect-type": "1.1.0",
     "expr-eval": "2.0.2",
     "fancy-log": "2.0.0",
-    "glob": "11.0.0",
+    "glob": "11.0.1",
     "gulp": "5.0.0",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.8",
     "jsep": "1.4.0",
     "karma": "6.4.4",
-    "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.3",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
+    "karma-spec-reporter": "0.0.36",
+    "karma-webdriver-launcher": "1.0.8",
     "karma-webpack": "5.0.1",
     "mkdirp": "3.0.1",
-    "mocha": "11.0.1",
+    "mocha": "11.1.0",
     "mocha-junit-reporter": "2.2.1",
     "ndarray": "1.0.19",
     "ndarray-determinant": "1.0.0",
@@ -89,9 +91,9 @@
     "process": "0.11.10",
     "sinon": "19.0.2",
     "sylvester": "0.0.21",
-    "tinybench": "3.0.7",
+    "tinybench": "3.1.0",
     "ts-node": "10.9.2",
-    "typescript": "5.7.2",
+    "typescript": "5.7.3",
     "webpack": "5.97.1",
     "zeros": "1.0.0"
   },
@@ -151,7 +153,7 @@
     "test:node": "mocha test/node-tests/*.test.js test/node-tests/**/*.test.js",
     "test:all": "npm run test:src && npm run test:generated && npm run test:node && npm run test:types",
     "test:browser": "karma start test/browser-test-config/local-karma.js",
-    "test:browserstack": "karma start test/browser-test-config/browserstack-karma.js",
+    "test:lambdatest": "karma start test/browser-test-config/lambdatest-karma.js",
     "test:types": " tsc -p ./tsconfig.json && node --loader ts-node/esm ./test/typescript-tests/testTypes.ts",
     "coverage": "c8 --reporter=lcov --reporter=text-summary mocha test/unit-tests && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"",
     "prepublishOnly": "npm run test:all && npm run lint",

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,

package/lib/esm/expression/transform/apply.transform.js

@@ -1,44 +0,0 @@
-import { errorTransform } from './utils/errorTransform.js';
-import { factory } from '../../utils/factory.js';
-import { createApply } from '../../function/matrix/apply.js';
-import { isBigNumber, isNumber } from '../../utils/is.js';
-var name = 'apply';
-var dependencies = ['typed', 'isInteger'];
-
-/**
- * Attach a transform function to math.apply
- * Adds a property transform containing the transform function.
- *
- * This transform changed the last `dim` parameter of function apply
- * from one-based to zero based
- */
-export var createApplyTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
-  var {
-    typed,
-    isInteger
-  } = _ref;
-  var apply = createApply({
-    typed,
-    isInteger
-  });
-
-  // @see: comment of concat itself
-  return typed('apply', {
-    '...any': function any(args) {
-      // change dim from one-based to zero-based
-      var dim = args[1];
-      if (isNumber(dim)) {
-        args[1] = dim - 1;
-      } else if (isBigNumber(dim)) {
-        args[1] = dim.minus(1);
-      }
-      try {
-        return apply.apply(null, args);
-      } catch (err) {
-        throw errorTransform(err);
-      }
-    }
-  });
-}, {
-  isTransformFunction: true
-});