mathjs 10.1.0 → 10.3.0

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
@@ -3121,6 +3134,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 +3174,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 +3218,6 @@ declare namespace math {
     ): MathNode;
 
     rules: SimplifyRule[];
-
-    simplifyCore(expr: MathNode): MathNode;
   }
 
   interface UnitDefinition {
@@ -3409,11 +3449,11 @@ declare namespace math {
 
   interface ConfigOptions {
     epsilon?: number;
-    matrix?: string;
-    number?: string;
+    matrix?: 'Matrix' | 'Array';
+    number?: 'number' | 'BigNumber' | 'Fraction';
     precision?: number;
-    parenthesis?: string;
-    randomSeed?: string;
+    predictable?: boolean;
+    randomSeed?: string | null;
   }
 
   interface MathJsJson {
@@ -3640,6 +3680,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 +4319,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

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;
-});