mathjs 10.1.1 → 10.4.0

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

@@ -9,27 +9,39 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * Create a fraction convert a value to a fraction.
+   * Create a fraction or convert a value to a fraction.
+   *
+   * With one numeric argument, produces the closest rational approximation to the
+   * input.
+   * With two arguments, the first is the numerator and the second is the denominator,
+   * and creates the corresponding fraction. Both numerator and denominator must be
+   * integers.
+   * With one object argument, looks for the integer numerator as the value of property
+   * 'n' and the integer denominator as the value of property 'd'.
+   * With a matrix argument, creates a matrix of the same shape with entries
+   * converted into fractions.
    *
    * Syntax:
+   *     math.fraction(value)
    *     math.fraction(numerator, denominator)
    *     math.fraction({n: numerator, d: denominator})
-   *     math.fraction(matrix: Array | Matrix)         Turn all matrix entries
-   *                                                   into fractions
+   *     math.fraction(matrix: Array | Matrix)
    *
    * Examples:
    *
-   *     math.fraction(1, 3)
-   *     math.fraction('2/3')
-   *     math.fraction({n: 2, d: 3})
-   *     math.fraction([0.2, 0.25, 1.25])
+   *     math.fraction(6.283)             // returns Fraction 6283/1000
+   *     math.fraction(1, 3)              // returns Fraction 1/3
+   *     math.fraction('2/3')             // returns Fraction 2/3
+   *     math.fraction({n: 2, d: 3})      // returns Fraction 2/3
+   *     math.fraction([0.2, 0.25, 1.25]) // returns Array [1/5, 1/4, 5/4]
+   *     math.fraction(4, 5.1)            // throws Error: Parameters must be integer
    *
    * See also:
    *
    *    bignumber, number, string, unit
    *
    * @param {number | string | Fraction | BigNumber | Array | Matrix} [args]
-   *            Arguments specifying the numerator and denominator of
+   *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
    */

package/lib/esm/utils/collection.js

@@ -1,6 +1,7 @@
 import { isCollection, isMatrix } from './is.js';
 import { IndexError } from '../error/IndexError.js';
 import { arraySize } from './array.js';
+import { _switch } from './switch.js';
 /**
  * Test whether an array contains collections
  * @param {Array} array
@@ -127,32 +128,6 @@ function _reduce(mat, dim, callback) {
 
     return ret;
   }
-}
-/**
- * Transpose a matrix
- * @param {Array} mat
- * @returns {Array} ret
- * @private
- */
-
-
-function _switch(mat) {
-  var I = mat.length;
-  var J = mat[0].length;
-  var i, j;
-  var ret = [];
-
-  for (j = 0; j < J; j++) {
-    var tmp = [];
-
-    for (i = 0; i < I; i++) {
-      tmp.push(mat[i][j]);
-    }
-
-    ret.push(tmp);
-  }
-
-  return ret;
 } // TODO: document function scatter
 
 

package/lib/esm/utils/switch.js

@@ -0,0 +1,24 @@
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+export function _switch(mat) {
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+
+  for (j = 0; j < J; j++) {
+    var tmp = [];
+
+    for (i = 0; i < I; i++) {
+      tmp.push(mat[i][j]);
+    }
+
+    ret.push(tmp);
+  }
+
+  return ret;
+}

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '10.1.1'; // Note: This file is automatically generated when building math.js.
+export var version = '10.4.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": "10.1.1",
+  "version": "10.4.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",
@@ -25,26 +25,27 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
+    "@babel/runtime": "^7.17.2",
     "complex.js": "^2.0.15",
     "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.1.2",
+    "fraction.js": "^4.2.0",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
     "typed-function": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.16.12",
+    "@babel/core": "7.17.5",
     "@babel/plugin-transform-object-assign": "7.16.7",
-    "@babel/plugin-transform-runtime": "7.16.10",
+    "@babel/plugin-transform-runtime": "7.17.0",
     "@babel/preset-env": "7.16.11",
-    "@babel/register": "7.16.9",
+    "@babel/register": "7.17.0",
+    "assert": "2.0.0",
     "babel-loader": "8.2.3",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.21.0",
+    "core-js": "3.21.1",
     "del": "6.0.0",
     "dtslint": "4.2.1",
     "expr-eval": "2.0.2",
@@ -54,8 +55,8 @@
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
-    "jsep": "1.2.0",
-    "karma": "6.3.13",
+    "jsep": "1.3.0",
+    "karma": "6.3.16",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
@@ -72,6 +73,7 @@
     "numericjs": "1.2.6",
     "nyc": "15.1.0",
     "pad-right": "0.2.2",
+    "process": "0.11.10",
     "standard": "16.0.4",
     "sylvester": "0.0.21",
     "typescript": "4.5.5",
@@ -124,7 +126,7 @@
     "CONTRIBUTING.md"
   ],
   "scripts": {
-    "build": "gulp --gulpfile gulpfile.cjs",
+    "build": "gulp --gulpfile gulpfile.cjs && npm run update-authors",
     "build-and-test": "npm run build && npm run test:all && npm run lint",
     "build:clean": "gulp --gulpfile gulpfile.cjs clean",
     "build:docs": "gulp --gulpfile gulpfile.cjs docs",
@@ -161,5 +163,8 @@
     "src": "./src",
     "test": "./test"
   },
+  "browserslist": [
+    "IE 11"
+  ],
   "sideEffects": false
 }

package/types/index.d.ts

@@ -575,7 +575,7 @@ declare namespace math {
      * @param unit The unit to be created
      * @returns The created unit
      */
-    unit(value: number | MathArray | Matrix, unit: string): Unit;
+    unit(value: number | MathArray | Matrix | BigNumber, unit: string): Unit;
 
     /*************************************************************************
      * Expression functions
@@ -1674,6 +1674,19 @@ declare namespace math {
         column: number
     ): T;
 
+    /**
+     * Return a rotated matrix.
+     * @param {Array | Matrix} w                             Vector to rotate
+     * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+     * @param {Array | Matrix} [v]                           Rotation axis
+     * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
+     */
+         rotate<T extends MathArray | Matrix>(
+          w: T,
+          theta: number | BigNumber | Complex | Unit,
+          v?: T
+      ): T;
+
     /**
      * Calculate the size of a matrix or scalar.
      * @param A matrix
@@ -1710,7 +1723,7 @@ declare namespace math {
     /**
      * Get or set a subset of a matrix or string.
      * @param value An array, matrix, or string
-     * @param index An index containing ranges for each dimension
+     * @param index For each dimension, an index or list of indices to get or set.
      * @param replacement An array, matrix, or scalar. If provided, the
      * subset is replaced with replacement. If not provided, the subset is
      * returned
@@ -1783,7 +1796,7 @@ declare namespace math {
      * @param n A real or complex number
      * @returns The gamma of n
      */
-    gamma(n: number | MathArray | Matrix): number | MathArray | Matrix;
+    gamma<T extends number | BigNumber | Complex | MathArray | Matrix>(n: T): NoLiteralType<T>;
 
     /**
      * Calculate the Kullback-Leibler (KL) divergence between two
@@ -2210,6 +2223,38 @@ declare namespace math {
      */
     quantileSeq(A: MathArray | Matrix, prob: number | BigNumber | MathArray, sorted?: boolean): number | BigNumber | Unit | MathArray;
 
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * 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
+     */
+    std(...values: number[]): number
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * 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 array A single matrix to compute standard deviation.
+     * @param dimension A dimension to calculate standard deviation
+     * @param normalization Determines how to normalize the variance. Choose
+     * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
+     * ‘unbiased’.
+     * @returns The standard deviation array
+     */
+    std(array: MathArray | Matrix, dimension: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number[]
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -2226,7 +2271,7 @@ declare namespace math {
      * ‘unbiased’.
      * @returns The standard deviation
      */
-    std(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): number;
+    std(array: MathArray | Matrix, normalization: 'unbiased' | 'uncorrected' | 'biased'): number
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -2242,6 +2287,21 @@ declare namespace math {
      */
     sum(array: MathArray | Matrix): any;
 
+    /**
+     * Compute the cumulative sum of a matrix or a list with values.
+     * In case of a (multi dimensional) array or matrix, the cumulative sums
+     * along a specified dimension (defaulting to the first) will be calculated.
+     * @param args A single matrix or multiple scalar values
+     * @returns The cumulative sums of the the values.
+     */
+    cumsum(...args: MathType[]): MathType[];
+    /**
+     * @param array A single matrix
+     * @param dim The dimension along which to sum (defaults to 0)
+     * @returns The cumulative sums along the given dimension
+     */
+    cumsum(array: MathArray | Matrix, dim?: number): MathArray | Matrix;
+
     /**
      * 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
@@ -2256,7 +2316,26 @@ declare namespace math {
      * @param args A single matrix or multiple scalar values
      * @returns The variance
      */
-    variance(...args: Array<number | BigNumber | Fraction>): any;
+    variance(...args: Array<number | BigNumber | Fraction>): number;
+    /**
+     * 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
+     * will be calculated. Optionally, the type of normalization can be
+     * specified as second parameter. The parameter normalization can be one
+     * of the following 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) Note that older browser may not like the variable name var. In
+     * that case, the function can be called as math['var'](...) instead of
+     * math.variance(...).
+     * @param array A matrix to compute variance.
+     * @param dimension A dimension to compute variance on
+     * @param normalization normalization Determines how to normalize the
+     * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
+     * Default value: ‘unbiased’.
+     * @returns variance matrix.
+     */
+    variance(array: MathArray | Matrix, dimension: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number[];
     /**
      * @param array A single matrix
      * @param normalization normalization Determines how to normalize the
@@ -2264,7 +2343,7 @@ declare namespace math {
      * Default value: ‘unbiased’.
      * @returns The variance
      */
-    variance(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): any;
+    variance(array: MathArray | Matrix, normalization?: 'unbiased' | 'uncorrected' | 'biased'): number;
 
     /*************************************************************************
      * String functions
@@ -3121,6 +3200,28 @@ declare namespace math {
     fixPrefix?: boolean;
   }
 
+  interface UnitComponent {
+    power: number;
+    prefix: string;
+    unit: {
+      name: string;
+      base: {
+        dimensions: number[];
+        key: string;
+      };
+      prefixes: Record<string, UnitPrefix>;
+      value: number;
+      offset: number;
+      dimensions: number[];
+    };
+  }
+
+  interface UnitPrefix {
+    name: string;
+    value: number;
+    scientific: boolean;
+  }
+
   interface Unit {
     valueOf(): string;
     clone(): Unit;
@@ -3139,7 +3240,14 @@ declare namespace math {
     toJSON(): MathJSON;
     formatUnits(): string;
     format(options: FormatOptions): string;
+    simplify(): Unit;
     splitUnit(parts: ReadonlyArray<string | Unit>): Unit[];
+
+    units: UnitComponent[];
+    dimensions: number[];
+    value: number;
+    fixPrefix: boolean;
+    skipAutomaticSimplification: true;
   }
 
   interface CreateUnitOptions {
@@ -3176,8 +3284,6 @@ declare namespace math {
     ): MathNode;
 
     rules: SimplifyRule[];
-
-    simplifyCore(expr: MathNode): MathNode;
   }
 
   interface UnitDefinition {
@@ -3640,6 +3746,8 @@ declare namespace math {
      */
     simplify(rules?: SimplifyRule[], scope?: object): MathJsChain;
 
+    simplifyCore(expr: MathNode): MathNode;
+
     /**
      * Calculate the Sparse Matrix LU decomposition with full pivoting.
      * Sparse Matrix A is decomposed in two matrices (L, U) and two
@@ -4277,7 +4385,7 @@ declare namespace math {
 
     /**
      * Get or set a subset of a matrix or string.
-     * @param index An index containing ranges for each dimension
+     * @param index For each dimension, an index or list of indices to get or set
      * @param replacement An array, matrix, or scalar. If provided, the
      * subset is replaced with replacement. If not provided, the subset is
      * returned
@@ -4664,7 +4772,24 @@ declare namespace math {
      * @param sorted =false is data sorted in ascending order
      */
     quantileSeq(prob: number | BigNumber | MathArray, sorted?: boolean): MathJsChain;
-
+    /**
+     * Compute the standard deviation of a matrix or a list with values. The
+     * standard deviations is defined as the square root of the variance:
+     * std(A) = sqrt(variance(A)). In case of a (multi dimensional) array or
+     * matrix, the standard deviation over all elements will be calculated.
+     * Optionally, the type of normalization can be specified as second
+     * parameter. The parameter normalization can be one of the following
+     * 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 array A single matrix or multiple scalar values
+     * @param dim A dimension to compute standard deviation.
+     * @param normalization Determines how to normalize the variance. Choose
+     * ‘unbiased’ (default), ‘uncorrected’, or ‘biased’. Default value:
+     * ‘unbiased’.
+     * @returns The standard deviation
+     */
+    std(dim: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
     /**
      * Compute the standard deviation of a matrix or a list with values. The
      * standard deviations is defined as the square root of the variance:
@@ -4681,7 +4806,7 @@ declare namespace math {
      * ‘unbiased’.
      * @returns The standard deviation
      */
-    std(normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): MathJsChain;
+    std(normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
 
     /**
      * Compute the sum of a matrix or a list with values. In case of a
@@ -4689,7 +4814,24 @@ declare namespace math {
      * calculated.
      */
     sum(): MathJsChain;
-
+    /**
+     * 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
+     * will be calculated. Optionally, the type of normalization can be
+     * specified as second parameter. The parameter normalization can be one
+     * of the following 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) Note that older browser may not like the variable name var. In
+     * that case, the function can be called as math['var'](...) instead of
+     * math.variance(...).
+     * @param dim a dimension to compute variance.
+     * @param normalization normalization Determines how to normalize the
+     * variance. Choose ‘unbiased’ (default), ‘uncorrected’, or ‘biased’.
+     * Default value: ‘unbiased’.
+     * @returns The variance
+     */
+    variance(dim: number, normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
     /**
      * 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
@@ -4706,7 +4848,7 @@ declare namespace math {
      * Default value: ‘unbiased’.
      * @returns The variance
      */
-    variance(normalization?: 'unbiased' | 'uncorrected' | 'biased' | 'unbiased'): MathJsChain;
+    variance(normalization?: 'unbiased' | 'uncorrected' | 'biased'): MathJsChain;
 
     /*************************************************************************
      * String functions

package/lib/cjs/function/algebra/simplify/resolve.js

@@ -1,76 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createResolve = void 0;
-
-var _map = require("../../../utils/map.js");
-
-var _is = require("../../../utils/is.js");
-
-var _factory = require("../../../utils/factory.js");
-
-var name = 'resolve';
-var dependencies = ['parse', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
-var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var parse = _ref.parse,
-      FunctionNode = _ref.FunctionNode,
-      OperatorNode = _ref.OperatorNode,
-      ParenthesisNode = _ref.ParenthesisNode;
-
-  /**
-   * resolve(expr, scope) replaces variable nodes with their scoped values
-   *
-   * Syntax:
-   *
-   *     simplify.resolve(expr, scope)
-   *
-   * Examples:
-   *
-   *     math.simplify.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
-   *     math.simplify.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
-   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
-   *
-   * @param {Node} node
-   *     The expression tree to be simplified
-   * @param {Object} scope with variables to be resolved
-   */
-  function resolve(node, scope) {
-    if (!scope) {
-      return node;
-    }
-
-    if (!(0, _map.isMap)(scope)) {
-      scope = (0, _map.createMap)(scope);
-    }
-
-    if ((0, _is.isSymbolNode)(node)) {
-      var value = scope.get(node.name);
-
-      if ((0, _is.isNode)(value)) {
-        return resolve(value, scope);
-      } else if (typeof value === 'number') {
-        return parse(String(value));
-      }
-    } else if ((0, _is.isOperatorNode)(node)) {
-      var args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-      return new OperatorNode(node.op, node.fn, args, node.implicit);
-    } else if ((0, _is.isParenthesisNode)(node)) {
-      return new ParenthesisNode(resolve(node.content, scope));
-    } else if ((0, _is.isFunctionNode)(node)) {
-      var _args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-
-      return new FunctionNode(node.name, _args);
-    }
-
-    return node;
-  }
-
-  return resolve;
-});
-exports.createResolve = createResolve;

package/lib/esm/function/algebra/simplify/resolve.js

@@ -1,67 +0,0 @@
-import { createMap, isMap } from '../../../utils/map.js';
-import { isFunctionNode, isNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
-import { factory } from '../../../utils/factory.js';
-var name = 'resolve';
-var dependencies = ['parse', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
-export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
-  var {
-    parse,
-    FunctionNode,
-    OperatorNode,
-    ParenthesisNode
-  } = _ref;
-
-  /**
-   * resolve(expr, scope) replaces variable nodes with their scoped values
-   *
-   * Syntax:
-   *
-   *     simplify.resolve(expr, scope)
-   *
-   * Examples:
-   *
-   *     math.simplify.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
-   *     math.simplify.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
-   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
-   *
-   * @param {Node} node
-   *     The expression tree to be simplified
-   * @param {Object} scope with variables to be resolved
-   */
-  function resolve(node, scope) {
-    if (!scope) {
-      return node;
-    }
-
-    if (!isMap(scope)) {
-      scope = createMap(scope);
-    }
-
-    if (isSymbolNode(node)) {
-      var value = scope.get(node.name);
-
-      if (isNode(value)) {
-        return resolve(value, scope);
-      } else if (typeof value === 'number') {
-        return parse(String(value));
-      }
-    } else if (isOperatorNode(node)) {
-      var args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-      return new OperatorNode(node.op, node.fn, args, node.implicit);
-    } else if (isParenthesisNode(node)) {
-      return new ParenthesisNode(resolve(node.content, scope));
-    } else if (isFunctionNode(node)) {
-      var _args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-
-      return new FunctionNode(node.name, _args);
-    }
-
-    return node;
-  }
-
-  return resolve;
-});