mathjs 10.1.1 → 10.2.0

package/lib/esm/function/algebra/{simplify/simplifyCore.js → simplifyCore.js}

@@ -1,7 +1,8 @@
-import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
-import { factory } from '../../../utils/factory.js';
+import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode } from '../../utils/is.js';
+import { createUtil } from './simplify/util.js';
+import { factory } from '../../utils/factory.js';
 var name = 'simplifyCore';
-var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode'];
+var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     equal,
@@ -18,16 +19,19 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
     IndexNode,
     ObjectNode,
     OperatorNode,
-    ParenthesisNode
+    ParenthesisNode,
+    SymbolNode
   } = _ref;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
-
-  function mapSimplifyCore(nodeArray) {
-    return nodeArray.map(simplifyCore).map(function (arg) {
-      return isParenthesisNode(arg) ? arg.content : arg;
-    });
-  }
+  var {
+    hasProperty,
+    isCommutative
+  } = createUtil({
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  });
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -36,31 +40,53 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
    *
    * Syntax:
    *
-   *     simplify.simplifyCore(expr)
+   *     simplifyCore(expr)
    *
    * Examples:
    *
    *     const f = math.parse('2 * 1 * x ^ (2 - 1)')
-   *     math.simplify.simpifyCore(f)                          // Node {2 * x}
-   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplify.simpifyCore]) // Node {2 * x}
+   *     math.simpifyCore(f)                          // Node {2 * x}
+   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplifyCore]) // Node {2 * x}
    *
    * See also:
    *
-   *     derivative
+   *     simplify, resolve, derivative
    *
    * @param {Node} node
    *     The expression to be simplified
+   * @param {Object} options
+   *     Simplification options, as per simplify()
+   * @return {Node} Returns expression with basic simplifications applied
    */
 
+  function simplifyCore(node, options) {
+    var context = options ? options.context : undefined;
 
-  function simplifyCore(node) {
-    if (isOperatorNode(node) && node.isUnary()) {
-      var a0 = simplifyCore(node.args[0]);
+    if (hasProperty(node, 'trivial', context)) {
+      // This node does nothing if it has only one argument, so if so,
+      // return that argument simplified
+      if (isFunctionNode(node) && node.args.length === 1) {
+        return simplifyCore(node.args[0], options);
+      } // For other node types, we try the generic methods
 
-      if (node.op === '+') {
-        // unary plus
-        return a0;
+
+      var simpChild = false;
+      var childCount = 0;
+      node.forEach(c => {
+        ++childCount;
+
+        if (childCount === 1) {
+          simpChild = simplifyCore(c, options);
+        }
+      });
+
+      if (childCount === 1) {
+        return simpChild;
       }
+    }
+
+    if (isOperatorNode(node) && node.isUnary()) {
+      var a0 = simplifyCore(node.args[0], options);
 
       if (node.op === '-') {
         // unary minus
@@ -75,9 +101,9 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
         return new OperatorNode(node.op, node.fn, [a0]);
       }
     } else if (isOperatorNode(node) && node.isBinary()) {
-      var _a = simplifyCore(node.args[0]);
+      var _a = simplifyCore(node.args[0], options);
 
-      var a1 = simplifyCore(node.args[1]);
+      var a1 = simplifyCore(node.args[1], options);
 
       if (node.op === '+') {
         if (isConstantNode(_a)) {
@@ -113,7 +139,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
 
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
-            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]));
+            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
           }
 
           return new OperatorNode(node.op, node.fn, [_a, a1]);
@@ -134,7 +160,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
-          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op) {
+          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op && isCommutative(node, context)) {
             var a00 = _a.args[0];
 
             if (isConstantNode(a00)) {
@@ -143,7 +169,11 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             }
           }
 
-          return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
+          if (isCommutative(node, context)) {
+            return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
+          } else {
+            return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
+          }
         }
 
         return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
@@ -179,33 +209,19 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
 
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-    } else if (isParenthesisNode(node)) {
-      var c = simplifyCore(node.content);
-
-      if (isParenthesisNode(c) || isSymbolNode(c) || isConstantNode(c)) {
-        return c;
-      }
-
-      return new ParenthesisNode(c);
     } else if (isFunctionNode(node)) {
-      return new FunctionNode(simplifyCore(node.fn), mapSimplifyCore(node.args));
+      return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
     } else if (isArrayNode(node)) {
-      return new ArrayNode(mapSimplifyCore(node.items));
+      return new ArrayNode(node.items.map(n => simplifyCore(n, options)));
     } else if (isAccessorNode(node)) {
-      var obj = mapSimplifyCore(node.object);
-
-      if (isParenthesisNode(obj)) {
-        obj = obj.content;
-      }
-
-      return new AccessorNode(obj, simplifyCore(node.index));
+      return new AccessorNode(simplifyCore(node.object, options), simplifyCore(node.index, options));
     } else if (isIndexNode(node)) {
-      return new IndexNode(mapSimplifyCore(node.dimensions));
+      return new IndexNode(node.dimensions.map(n => simplifyCore(n, options)));
     } else if (isObjectNode(node)) {
       var newProps = {};
 
       for (var prop in node.properties) {
-        newProps[prop] = simplifyCore(node.properties[prop]);
+        newProps[prop] = simplifyCore(node.properties[prop], options);
       }
 
       return new ObjectNode(newProps);

package/lib/esm/plain/number/combinations.js

@@ -14,14 +14,26 @@ export function combinationsNumber(n, k) {
   }
 
   var nMinusk = n - k;
-  var prodrange;
+  var answer = 1;
+  var firstnumerator = k < nMinusk ? nMinusk + 1 : k + 1;
+  var nextdivisor = 2;
+  var lastdivisor = k < nMinusk ? k : nMinusk; // balance multiplications and divisions to try to keep intermediate values
+  // in exact-integer range as long as possible
 
-  if (k < nMinusk) {
-    prodrange = product(nMinusk + 1, n);
-    return prodrange / product(1, k);
+  for (var nextnumerator = firstnumerator; nextnumerator <= n; ++nextnumerator) {
+    answer *= nextnumerator;
+
+    while (nextdivisor <= lastdivisor && answer % nextdivisor === 0) {
+      answer /= nextdivisor;
+      ++nextdivisor;
+    }
+  } // for big n, k, floating point may have caused weirdness in remainder
+
+
+  if (nextdivisor <= lastdivisor) {
+    answer /= product(nextdivisor, lastdivisor);
   }
 
-  prodrange = product(k + 1, n);
-  return prodrange / product(1, nMinusk);
+  return answer;
 }
 combinationsNumber.signature = 'number, number';

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.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": "10.1.1",
+  "version": "10.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",
@@ -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.1.3",
     "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
@@ -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 {

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