mathjs 11.8.0 → 11.8.2

package/lib/esm/type/bignumber/function/bignumber.js

@@ -63,6 +63,11 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref =>
       // we assume a BigNumber is immutable
       return x;
     },
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     Fraction: function Fraction(x) {
       return new BigNumber(x.n).div(x.d).times(x.s);
     },

package/lib/esm/type/fraction/function/fraction.js

@@ -39,7 +39,7 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    bignumber, number, string, unit
    *
-   * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
+   * @param {number | string | Fraction | BigNumber | Unit | Array | Matrix} [args]
    *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
@@ -67,6 +67,11 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x; // fractions are immutable
     },
 
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     Object: function Object(x) {
       return new Fraction(x);
     },

package/lib/esm/type/number.js

@@ -121,9 +121,11 @@ export var createNumber = /* #__PURE__ */factory(name, dependencies, _ref => {
     Fraction: function Fraction(x) {
       return x.valueOf();
     },
-    Unit: function Unit(x) {
-      throw new Error('Second argument with valueless unit expected');
-    },
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     null: function _null(x) {
       return 0;
     },

package/lib/esm/type/unit/function/splitUnit.js

@@ -10,7 +10,7 @@ export var createSplitUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    * Syntax:
    *
-   *     splitUnit(unit: Unit, parts: Array.<Unit>)
+   *     math.splitUnit(unit: Unit, parts: Array.<Unit>)
    *
    * Example:
    *

package/lib/esm/utils/applyCallback.js

@@ -0,0 +1,67 @@
+import typed from 'typed-function';
+import { typeOf as _typeOf } from './is.js';
+
+/**
+ * Invoke a callback for functions like map and filter with a matching number of arguments
+ * @param {function} callback
+ * @param {any} value
+ * @param {number | number[]} index
+ * @param {Array} array
+ * @param {string} mappingFnName   The name of the function that is invoking these callbacks, for example "map" or "filter"
+ * @returns {*}
+ */
+export function applyCallback(callback, value, index, array, mappingFnName) {
+  if (typed.isTypedFunction(callback)) {
+    // invoke the typed callback function with the matching number of arguments only
+
+    var args3 = [value, index, array];
+    var signature3 = typed.resolve(callback, args3);
+    if (signature3) {
+      return tryWithArgs(signature3.implementation, args3);
+    }
+    var args2 = [value, index];
+    var signature2 = typed.resolve(callback, args2);
+    if (signature2) {
+      return tryWithArgs(signature2.implementation, args2);
+    }
+    var args1 = [value];
+    var signature1 = typed.resolve(callback, args1);
+    if (signature1) {
+      return tryWithArgs(signature1.implementation, args1);
+    }
+
+    // fallback (will throw an exception)
+    return tryWithArgs(callback, args3);
+  } else {
+    // A regular JavaScript function
+    return callback(value, index, array);
+  }
+
+  /**
+   * @param {function} signature The selected signature of the typed-function
+   * @param {Array} args List with arguments to apply to the selected signature
+   * @returns {*} Returns the return value of the invoked signature
+   * @throws {TypeError} Throws an error when no matching signature was found
+   */
+  function tryWithArgs(signature, args) {
+    try {
+      return signature.apply(signature, args);
+    } catch (err) {
+      var _err$data;
+      // Enrich the error message so the user understands that it took place inside the callback function
+      if (err instanceof TypeError && ((_err$data = err.data) === null || _err$data === void 0 ? void 0 : _err$data.category) === 'wrongType') {
+        var argsDesc = [];
+        argsDesc.push("value: ".concat(_typeOf(value)));
+        if (args.length >= 2) {
+          argsDesc.push("index: ".concat(_typeOf(index)));
+        }
+        if (args.length >= 3) {
+          argsDesc.push("array: ".concat(_typeOf(array)));
+        }
+        throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "".concat(callback.name, "(").concat(argsDesc.join(', '), ") at index ").concat(JSON.stringify(index)));
+      } else {
+        throw new TypeError("Function ".concat(mappingFnName, " cannot apply callback arguments ") + "to function ".concat(callback.name, ": ").concat(err.message));
+      }
+    }
+  }
+}

package/lib/esm/utils/bignumber/formatter.js

@@ -146,7 +146,7 @@ export function format(value, options) {
     // determine precision from options
     if (typeof options === 'number') {
       precision = options;
-    } else if (options.precision) {
+    } else if (options.precision !== undefined) {
       precision = options.precision;
     }
     if (options.wordSize) {
@@ -207,7 +207,7 @@ export function format(value, options) {
 
 /**
  * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
- * @param {BigNumber | string} value
+ * @param {BigNumber} value
  * @param {number} [precision]        Optional number of significant figures to return.
  */
 export function toEngineering(value, precision) {
@@ -219,7 +219,8 @@ export function toEngineering(value, precision) {
   var valueWithoutExp = value.mul(Math.pow(10, -newExp));
   var valueStr = valueWithoutExp.toPrecision(precision);
   if (valueStr.indexOf('e') !== -1) {
-    valueStr = valueWithoutExp.toString();
+    var BigNumber = value.constructor;
+    valueStr = new BigNumber(valueStr).toFixed();
   }
   return valueStr + 'e' + (e >= 0 ? '+' : '') + newExp.toString();
 }

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '11.8.0';
+export var version = '11.8.2';
 // 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": "11.8.0",
+  "version": "11.8.2",
   "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",
@@ -25,7 +25,7 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.21.0",
+    "@babel/runtime": "^7.22.5",
     "complex.js": "^2.1.1",
     "decimal.js": "^10.4.3",
     "escape-latex": "^1.2.0",
@@ -36,32 +36,32 @@
     "typed-function": "^4.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.21.4",
-    "@babel/plugin-transform-object-assign": "7.18.6",
-    "@babel/plugin-transform-runtime": "7.21.4",
-    "@babel/preset-env": "7.21.4",
-    "@babel/register": "7.21.0",
+    "@babel/core": "7.22.5",
+    "@babel/plugin-transform-object-assign": "7.22.5",
+    "@babel/plugin-transform-runtime": "7.22.5",
+    "@babel/preset-env": "7.22.5",
+    "@babel/register": "7.22.5",
     "@types/assert": "1.5.6",
     "@types/mocha": "10.0.1",
-    "@typescript-eslint/eslint-plugin": "5.57.0",
-    "@typescript-eslint/parser": "5.57.0",
+    "@typescript-eslint/eslint-plugin": "5.60.0",
+    "@typescript-eslint/parser": "5.60.0",
     "assert": "2.0.0",
     "babel-loader": "9.1.2",
     "benchmark": "2.1.4",
-    "c8": "7.13.0",
+    "c8": "8.0.0",
     "codecov": "3.8.3",
-    "core-js": "3.29.1",
+    "core-js": "3.31.0",
     "del": "6.1.1",
     "dtslint": "4.2.1",
-    "eslint": "8.37.0",
+    "eslint": "8.43.0",
     "eslint-config-prettier": "8.8.0",
-    "eslint-config-standard": "17.0.0",
+    "eslint-config-standard": "17.1.0",
     "eslint-plugin-import": "2.27.5",
     "eslint-plugin-mocha": "10.1.0",
-    "eslint-plugin-n": "15.7.0",
+    "eslint-plugin-n": "16.0.0",
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-promise": "6.1.1",
-    "expect-type": "0.15.0",
+    "expect-type": "0.16.0",
     "expr-eval": "2.0.2",
     "fancy-log": "2.0.0",
     "glob": "8.1.0",
@@ -69,7 +69,7 @@
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
     "jsep": "1.3.8",
-    "karma": "6.4.1",
+    "karma": "6.4.2",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
@@ -85,12 +85,12 @@
     "ndarray-pack": "1.2.1",
     "numericjs": "1.2.6",
     "pad-right": "0.2.2",
-    "prettier": "2.8.7",
+    "prettier": "2.8.8",
     "process": "0.11.10",
     "sylvester": "0.0.21",
     "ts-node": "10.9.1",
-    "typescript": "5.0.3",
-    "webpack": "5.77.0",
+    "typescript": "5.1.3",
+    "webpack": "5.87.0",
     "zeros": "1.0.0"
   },
   "type": "module",

package/types/index.d.ts

@@ -13,10 +13,12 @@ type NoLiteralType<T> = T extends number
   : T
 
 declare namespace math {
+  // TODO: introduce generics for MathCollection, MathMatrix, and MathArray
   type MathNumericType = number | BigNumber | Fraction | Complex
-  type MathArray = MathNumericType[] | MathNumericType[][]
+  type MathScalarType = MathNumericType | Unit
+  type MathArray = MathNumericType[] | MathNumericType[][] // TODO: MathArray can also contain Unit
   type MathCollection = MathArray | Matrix
-  type MathType = MathNumericType | Unit | MathCollection
+  type MathType = MathScalarType | MathCollection
   type MathExpression = string | string[] | MathCollection
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1581,12 +1583,14 @@ declare namespace math {
      * a 3D line, x0, y0, z0, a, b, c are from: (x−x0, y−y0, z−z0) = t(a, b,
      * c)
      * @param x Coordinates of the first point
-     * @param y Coordinates of the second point
+     * @param y Coordinates of the second point OR coefficients of a line in 3D OR first end-point of a line if the calculation is for distance between point and a line in 2D
+     * @param z Coordinates of second end-point of a line if the calculation is for distance between point and a line in 2D
      * @returns Returns the distance from two/three points
      */
     distance(
       x: MathCollection | object,
-      y: MathCollection | object
+      y: MathCollection | object,
+      z?: MathCollection | object
     ): number | BigNumber
 
     /**
@@ -2593,36 +2597,60 @@ declare namespace math {
      * of a multi dimensional array, the maximum of the flattened array will
      * be calculated. When dim is provided, the maximum over the selected
      * dimension will be calculated. Parameter dim is zero-based.
-     * @param args A single matrix or multiple scalar values
+     * @param args Multiple scalar values
      * @returns The maximum value
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    max(...args: MathType[]): any
+    max<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The maximum value
+     */
+    max(...args: MathScalarType[]): MathScalarType
     /**
      * @param A A single matrix
-     * @param dim The maximum over the selected dimension
+     * @param dimension The maximum over the selected dimension
      * @returns The maximum value
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    max(A: MathCollection, dim?: number): any
+    max<T extends MathScalarType>(
+      A: T[] | T[][],
+      dimension?: number | BigNumber
+    ): T
+    /**
+     * @param A A single matrix
+     * @param dimension The maximum over the selected dimension
+     * @returns The maximum value
+     */
+    max(A: MathCollection, dimension?: number | BigNumber): MathScalarType
 
     /**
      * Compute the mean value of matrix or a list with values. In case of a
      * multi dimensional array, the mean of the flattened array will be
      * calculated. When dim is provided, the maximum over the selected
      * dimension will be calculated. Parameter dim is zero-based.
-     * @param args A single matrix or multiple scalar values
+     * @param args Multiple scalar values
      * @returns The mean of all values
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mean(...args: MathType[]): any
+    mean<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The mean value
+     */
+    mean(...args: MathScalarType[]): MathScalarType
     /**
      * @param A A single matrix
-     * @param dim The mean over the selected dimension
-     * @returns The mean of all values
+     * @param dimension The mean over the selected dimension
+     * @returns The mean value
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mean(A: MathCollection, dim?: number): any
+    mean<T extends MathScalarType>(
+      A: T[] | T[][],
+      dimension?: number | BigNumber
+    ): T
+    /**
+     * @param A A single matrix
+     * @param dimension The mean over the selected dimension
+     * @returns The mean value
+     */
+    mean(A: MathCollection, dimension?: number | BigNumber): MathScalarType
 
     /**
      * Compute the median of a matrix or a list with values. The values are
@@ -2631,49 +2659,103 @@ declare namespace math {
      * types of values are: Number, BigNumber, Unit In case of a (multi
      * dimensional) array or matrix, the median of all elements will be
      * calculated.
-     * @param args A single matrix or or multiple scalar values
-     * @returns The median
+     * @param args Multiple scalar values
+     * @returns The median value
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    median(...args: MathType[]): any
+    median<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The median value
+     */
+    median(...args: MathScalarType[]): MathScalarType
+    /**
+     * @param A A single matrix
+     * @returns The median value
+     */
+    median<T extends MathScalarType>(A: T[] | T[][]): T
+    /**
+     * @param A A single matrix
+     * @returns The median value
+     */
+    median(A: MathCollection): MathScalarType
 
     /**
      * Compute the minimum value of a matrix or a list of values. In case of
-     * a multi dimensional array, the minimun of the flattened array will be
-     * calculated. When dim is provided, the minimun over the selected
+     * a multi dimensional array, the minimum of the flattened array will be
+     * calculated. When dim is provided, the minimum over the selected
      * dimension will be calculated. Parameter dim is zero-based.
-     * @param args A single matrix or or multiple scalar values
+     * @param args multiple scalar values
      * @returns The minimum value
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    min(...args: MathType[]): any
+    min<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The minimum value
+     */
+    min(...args: MathScalarType[]): MathScalarType
     /**
      * @param A A single matrix
-     * @param dim The minimum over the selected dimension
+     * @param dimension The minimum over the selected dimension
      * @returns The minimum value
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    min(A: MathCollection, dim?: number): any
+    min<T extends MathScalarType>(
+      A: T[] | T[][],
+      dimension?: number | BigNumber
+    ): T
+    /**
+     * @param A A single matrix
+     * @param dimension The minimum over the selected dimension
+     * @returns The minimum value
+     */
+    min(A: MathCollection, dimension?: number | BigNumber): MathScalarType
 
     /**
      * Computes the mode of a set of numbers or a list with values(numbers
      * or characters). If there are more than one modes, it returns a list
      * of those values.
-     * @param args A single matrix
+     * @param args Multiple scalar values
      * @returns The mode of all values
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mode(...args: MathType[]): any
+    mode<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The mode of all values
+     */
+    mode(...args: MathScalarType[]): MathScalarType
+    /**
+     * @param A A single matrix
+     * @returns The median value
+     */
+    mode<T extends MathScalarType>(A: T[] | T[][]): T
+    /**
+     * @param A A single matrix
+     * @returns The mode of all values
+     */
+    mode(A: MathCollection): MathScalarType
 
     /**
      * Compute the product of a matrix or a list with values. In case of a
      * (multi dimensional) array or matrix, the sum of all elements will be
      * calculated.
-     * @param args A single matrix or multiple scalar values
+     * @param args Multiple scalar values
      * @returns The product of all values
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    prod(...args: MathType[]): any
+    prod<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The product of all values
+     */
+    prod(...args: MathScalarType[]): MathScalarType
+    /**
+     * @param A A single matrix
+     * @returns The product of all values
+     */
+    prod<T extends MathScalarType>(A: T[] | T[][]): T
+    /**
+     * @param A A single matrix
+     * @returns The product of all values
+     */
+    prod(A: MathCollection): MathScalarType
 
     /**
      * Compute the prob order quantile of a matrix or a list with values.
@@ -2705,10 +2787,15 @@ declare namespace math {
      * values: 'unbiased' (default) The sum of squared errors is divided by
      * (n - 1) 'uncorrected' The sum of squared errors is divided by n
      * 'biased' The sum of squared errors is divided by (n + 1)
-     * @param a variadic argument of number to calculate standard deviation
-     * @returns The standard deviation array
+     * @param args variadic argument of number to calculate standard deviation
+     * @returns The standard deviation
      */
-    std(...values: number[]): number
+    std<T extends MathScalarType>(...args: T[]): T
+    /**
+     * @param args Multiple scalar values
+     * @returns The standard deviation
+     */
+    std(...args: MathScalarType[]): MathScalarType
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -2730,7 +2817,7 @@ declare namespace math {
       array: MathCollection,
       dimension?: number,
       normalization?: 'unbiased' | 'uncorrected' | 'biased'
-    ): number[]
+    ): MathNumericType[]
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -2750,7 +2837,7 @@ declare namespace math {
     std(
       array: MathCollection,
       normalization: 'unbiased' | 'uncorrected' | 'biased'
-    ): number
+    ): MathNumericType
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -2759,14 +2846,27 @@ declare namespace math {
      * @param args A single matrix or multiple scalar values
      * @returns The sum of all values
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    sum(...args: Array<number | BigNumber | Fraction>): any
+    sum<T extends MathScalarType>(...args: T[]): T
     /**
-     * @param array A single matrix
+     * @param args Multiple scalar values
      * @returns The sum of all values
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    sum(array: MathCollection): any
+    sum(...args: MathScalarType[]): MathScalarType
+    /**
+     * @param A A single matrix
+     * @param dimension The sum over the selected dimension
+     * @returns The sum of all values
+     */
+    sum<T extends MathScalarType>(
+      A: T[] | T[][],
+      dimension?: number | BigNumber
+    ): T
+    /**
+     * @param A A single matrix
+     * @param dimension The sum over the selected dimension
+     * @returns The sum of all values
+     */
+    sum(A: MathCollection, dimension?: number | BigNumber): MathScalarType
 
     /**
      * Count the number of elements of a matrix, array or string.
@@ -2804,8 +2904,7 @@ declare namespace math {
      * @param args A single matrix or multiple scalar values
      * @returns The variance
      */
-    variance(...args: Array<number | BigNumber | Fraction>): number
-
+    variance(...args: MathNumericType[]): MathNumericType
     /**
      * Compute the variance of a matrix or a list with values. In case of a
      * (multi dimensional) array or matrix, the variance over all elements
@@ -2828,7 +2927,7 @@ declare namespace math {
       array: MathCollection,
       dimension?: number,
       normalization?: 'unbiased' | 'uncorrected' | 'biased'
-    ): number[]
+    ): MathNumericType[]
     /**
      * @param array A single matrix
      * @param normalization normalization Determines how to normalize the
@@ -2839,7 +2938,7 @@ declare namespace math {
     variance(
       array: MathCollection,
       normalization: 'unbiased' | 'uncorrected' | 'biased'
-    ): number
+    ): MathNumericType
 
     /*************************************************************************
      * String functions
@@ -3781,7 +3880,7 @@ declare namespace math {
     equalBase(unit: Unit): boolean
     equals(unit: Unit): boolean
     multiply(unit: Unit): Unit
-    divide(unit: Unit): Unit
+    divide(unit: Unit): Unit | number
     pow(unit: Unit): Unit
     abs(unit: Unit): Unit
     to(unit: string): Unit