mathjs 10.6.2 → 11.0.0

package/lib/esm/expression/parse.js

@@ -1,6 +1,6 @@
 import _extends from "@babel/runtime/helpers/extends";
 import { factory } from '../utils/factory.js';
-import { isAccessorNode, isConstantNode, isFunctionNode, isOperatorNode, isSymbolNode } from '../utils/is.js';
+import { isAccessorNode, isConstantNode, isFunctionNode, isOperatorNode, isSymbolNode, rule2Node } from '../utils/is.js';
 import { deepMap } from '../utils/collection.js';
 import { hasOwnProperty } from '../utils/object.js';
 var name = 'parse';
@@ -614,7 +614,10 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
 
     if (state.token !== '' && state.token !== '\n' && state.token !== ';') {
       node = parseAssignment(state);
-      node.comment = state.comment;
+
+      if (state.comment) {
+        node.comment = state.comment;
+      }
     } // TODO: simplify this loop
 
 
@@ -632,7 +635,11 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       if (state.token !== '\n' && state.token !== ';' && state.token !== '') {
         node = parseAssignment(state);
-        node.comment = state.comment;
+
+        if (state.comment) {
+          node.comment = state.comment;
+        }
+
         visible = state.token !== ';';
         blocks.push({
           node,
@@ -646,7 +653,10 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     } else {
       if (!node) {
         node = new ConstantNode(undefined);
-        node.comment = state.comment;
+
+        if (state.comment) {
+          node.comment = state.comment;
+        }
       }
 
       return node;
@@ -1088,8 +1098,10 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
   }
   /**
    * Infamous "rule 2" as described in https://github.com/josdejong/mathjs/issues/792#issuecomment-361065370
+   * And as amended in https://github.com/josdejong/mathjs/issues/2370#issuecomment-1054052164
    * Explicit division gets higher precedence than implicit multiplication
-   * when the division matches this pattern: [number] / [number] [symbol]
+   * when the division matches this pattern:
+   *   [unaryPrefixOp]?[number] / [number] [symbol]
    * @return {Node} node
    * @private
    */
@@ -1102,7 +1114,7 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
 
     while (true) {
       // Match the "number /" part of the pattern "number / number symbol"
-      if (state.token === '/' && isConstantNode(last)) {
+      if (state.token === '/' && rule2Node(last)) {
         // Look ahead to see if the next token is a number
         tokenStates.push(_extends({}, state));
         getTokenSkipNewline(state); // Match the "number / number" part of the pattern
@@ -1796,7 +1808,13 @@ export var createParse = /* #__PURE__ */factory(name, dependencies, _ref => {
     var error = new SyntaxError(message + ' (char ' + c + ')');
     error.char = c;
     return error;
-  }
+  } // Now that we can parse, automatically convert strings to Nodes by parsing
+
 
+  typed.addConversion({
+    from: 'string',
+    to: 'Node',
+    convert: parse
+  });
   return parse;
 });

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

@@ -3,7 +3,7 @@ import { createStd } from '../../function/statistics/std.js';
 import { errorTransform } from './utils/errorTransform.js';
 import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
 var name = 'std';
-var dependencies = ['typed', 'sqrt', 'variance'];
+var dependencies = ['typed', 'map', 'sqrt', 'variance'];
 /**
  * Attach a transform function to math.std
  * Adds a property transform containing the transform function.
@@ -15,11 +15,13 @@ var dependencies = ['typed', 'sqrt', 'variance'];
 export var createStdTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    map,
     sqrt,
     variance
   } = _ref;
   var std = createStd({
     typed,
+    map,
     sqrt,
     variance
   });

package/lib/esm/factoriesAny.js

@@ -248,6 +248,7 @@ export { createCatalan } from './function/combinatorics/catalan.js';
 export { createComposition } from './function/combinatorics/composition.js';
 export { createLeafCount } from './function/algebra/leafCount.js';
 export { createSimplify } from './function/algebra/simplify.js';
+export { createSimplifyConstant } from './function/algebra/simplifyConstant.js';
 export { createSimplifyCore } from './function/algebra/simplifyCore.js';
 export { createResolve } from './function/algebra/resolve.js';
 export { createSymbolicEqual } from './function/algebra/symbolicEqual.js';

package/lib/esm/factoriesNumber.js

@@ -15,6 +15,7 @@ export { createChain } from './type/chain/function/chain.js'; // algebra
 
 export { createResolve } from './function/algebra/resolve.js';
 export { createSimplify } from './function/algebra/simplify.js';
+export { createSimplifyConstant } from './function/algebra/simplifyConstant.js';
 export { createSimplifyCore } from './function/algebra/simplifyCore.js';
 export { createDerivative } from './function/algebra/derivative.js';
 export { createRationalize } from './function/algebra/rationalize.js'; // arithmetic

package/lib/esm/function/algebra/derivative.js

@@ -56,39 +56,26 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
    *                         be simplified.
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode}    The derivative of `expr`
    */
-  var derivative = typed('derivative', {
-    'Node, SymbolNode, Object': function NodeSymbolNodeObject(expr, variable, options) {
-      var constNodes = {};
-      constTag(constNodes, expr, variable.name);
+  function plainDerivative(expr, variable) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      simplify: true
+    };
+    var constNodes = {};
+    constTag(constNodes, expr, variable.name);
 
-      var res = _derivative(expr, constNodes);
+    var res = _derivative(expr, constNodes);
 
-      return options.simplify ? simplify(res) : res;
-    },
-    'Node, SymbolNode': function NodeSymbolNode(expr, variable) {
-      return this(expr, variable, {
-        simplify: true
-      });
-    },
-    'string, SymbolNode': function stringSymbolNode(expr, variable) {
-      return this(parse(expr), variable);
-    },
-    'string, SymbolNode, Object': function stringSymbolNodeObject(expr, variable, options) {
-      return this(parse(expr), variable, options);
-    },
-    'string, string': function stringString(expr, variable) {
-      return this(parse(expr), parse(variable));
-    },
-    'string, string, Object': function stringStringObject(expr, variable, options) {
-      return this(parse(expr), parse(variable), options);
-    },
-    'Node, string': function NodeString(expr, variable) {
-      return this(expr, parse(variable));
-    },
-    'Node, string, Object': function NodeStringObject(expr, variable, options) {
-      return this(expr, parse(variable), options);
-    } // TODO: replace the 8 signatures above with 4 as soon as typed-function supports optional arguments
+    return options.simplify ? simplify(res) : res;
+  }
 
+  typed.addConversion({
+    from: 'identifier',
+    to: 'SymbolNode',
+    convert: parse
+  });
+  var derivative = typed(name, {
+    'Node, SymbolNode': plainDerivative,
+    'Node, SymbolNode, Object': plainDerivative
     /* TODO: implement and test syntax with order of derivatives -> implement as an option {order: number}
     'Node, SymbolNode, ConstantNode': function (expr, variable, {order}) {
       let res = expr
@@ -102,6 +89,11 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
     */
 
   });
+  typed.removeConversion({
+    from: 'identifier',
+    to: 'SymbolNode',
+    convert: parse
+  });
   derivative._simplify = true;
 
   derivative.toTex = function (deriv) {

package/lib/esm/function/algebra/leafCount.js

@@ -49,9 +49,6 @@ export var createLeafCount = /* #__PURE__ */factory(name, dependencies, _ref =>
 
 
   return typed(name, {
-    string: function string(expr) {
-      return this(parse(expr));
-    },
     Node: function Node(expr) {
       return countLeaves(expr);
     }

package/lib/esm/function/algebra/rationalize.js

@@ -1,8 +1,7 @@
 import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
-import { createSimplifyConstant } from './simplify/simplifyConstant.js';
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
+var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyConstant', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
 export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
@@ -15,6 +14,7 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     divide,
     pow,
     parse,
+    simplifyConstant,
     simplifyCore,
     simplify,
     fraction,
@@ -31,22 +31,7 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     SymbolNode,
     ParenthesisNode
   } = _ref;
-  var simplifyConstant = createSimplifyConstant({
-    typed,
-    config,
-    mathWithTransform,
-    matrix,
-    fraction,
-    bignumber,
-    AccessorNode,
-    ArrayNode,
-    ConstantNode,
-    FunctionNode,
-    IndexNode,
-    ObjectNode,
-    OperatorNode,
-    SymbolNode
-  });
+
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -100,116 +85,100 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
    *           {Expression Node}  node simplified expression
    *
    */
+  function _rationalize(expr) {
+    var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var detailed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
 
-  return typed(name, {
-    string: function string(expr) {
-      return this(parse(expr), {}, false);
-    },
-    'string, boolean': function stringBoolean(expr, detailed) {
-      return this(parse(expr), {}, detailed);
-    },
-    'string, Object': function stringObject(expr, scope) {
-      return this(parse(expr), scope, false);
-    },
-    'string, Object, boolean': function stringObjectBoolean(expr, scope, detailed) {
-      return this(parse(expr), scope, detailed);
-    },
-    Node: function Node(expr) {
-      return this(expr, {}, false);
-    },
-    'Node, boolean': function NodeBoolean(expr, detailed) {
-      return this(expr, {}, detailed);
-    },
-    'Node, Object': function NodeObject(expr, scope) {
-      return this(expr, scope, false);
-    },
-    'Node, Object, boolean': function NodeObjectBoolean(expr, scope, detailed) {
-      var setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
-
-      var polyRet = polynomial(expr, scope, true, setRules.firstRules); // Check if expression is a rationalizable polynomial
-
-      var nVars = polyRet.variables.length;
-      var noExactFractions = {
-        exactFractions: false
-      };
-      var withExactFractions = {
-        exactFractions: true
-      };
-      expr = polyRet.expression;
-
-      if (nVars >= 1) {
-        // If expression in not a constant
-        expr = expandPower(expr); // First expand power of polynomials (cannot be made from rules!)
-
-        var sBefore; // Previous expression
-
-        var rules;
-        var eDistrDiv = true;
-        var redoInic = false; // Apply the initial rules, including succ div rules:
-
-        expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
-        var s;
-
-        while (true) {
-          // Alternate applying successive division rules and distr.div.rules
-          // until there are no more changes:
-          rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
-          expr = simplify(expr, rules, {}, withExactFractions);
-          eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
-
-          s = expr.toString();
-
-          if (s === sBefore) {
-            break; // No changes : end of the loop
-          }
+    var polyRet = polynomial(expr, scope, true, setRules.firstRules); // Check if expression is a rationalizable polynomial
 
-          redoInic = true;
-          sBefore = s;
-        }
+    var nVars = polyRet.variables.length;
+    var noExactFractions = {
+      exactFractions: false
+    };
+    var withExactFractions = {
+      exactFractions: true
+    };
+    expr = polyRet.expression;
 
-        if (redoInic) {
-          // Apply first rules again without succ div rules (if there are changes)
-          expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
-        } // Apply final rules:
+    if (nVars >= 1) {
+      // If expression in not a constant
+      expr = expandPower(expr); // First expand power of polynomials (cannot be made from rules!)
 
+      var sBefore; // Previous expression
 
-        expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
-      } // NVars >= 1
+      var rules;
+      var eDistrDiv = true;
+      var redoInic = false; // Apply the initial rules, including succ div rules:
 
+      expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
+      var s;
 
-      var coefficients = [];
-      var retRationalize = {};
+      while (true) {
+        // Alternate applying successive division rules and distr.div.rules
+        // until there are no more changes:
+        rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
+        expr = simplify(expr, rules, {}, withExactFractions);
+        eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
 
-      if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
-        // Separate numerator from denominator
-        if (nVars === 1) {
-          expr.args[0] = polyToCanonical(expr.args[0], coefficients);
-          expr.args[1] = polyToCanonical(expr.args[1]);
-        }
+        s = expr.toString();
 
-        if (detailed) {
-          retRationalize.numerator = expr.args[0];
-          retRationalize.denominator = expr.args[1];
-        }
-      } else {
-        if (nVars === 1) {
-          expr = polyToCanonical(expr, coefficients);
+        if (s === sBefore) {
+          break; // No changes : end of the loop
         }
 
-        if (detailed) {
-          retRationalize.numerator = expr;
-          retRationalize.denominator = null;
-        }
-      } // nVars
+        redoInic = true;
+        sBefore = s;
+      }
+
+      if (redoInic) {
+        // Apply first rules again without succ div rules (if there are changes)
+        expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
+      } // Apply final rules:
+
+
+      expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
+    } // NVars >= 1
+
+
+    var coefficients = [];
+    var retRationalize = {};
 
+    if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
+      // Separate numerator from denominator
+      if (nVars === 1) {
+        expr.args[0] = polyToCanonical(expr.args[0], coefficients);
+        expr.args[1] = polyToCanonical(expr.args[1]);
+      }
 
-      if (!detailed) return expr;
-      retRationalize.coefficients = coefficients;
-      retRationalize.variables = polyRet.variables;
-      retRationalize.expression = expr;
-      return retRationalize;
-    } // ^^^^^^^ end of rationalize ^^^^^^^^
+      if (detailed) {
+        retRationalize.numerator = expr.args[0];
+        retRationalize.denominator = expr.args[1];
+      }
+    } else {
+      if (nVars === 1) {
+        expr = polyToCanonical(expr, coefficients);
+      }
 
+      if (detailed) {
+        retRationalize.numerator = expr;
+        retRationalize.denominator = null;
+      }
+    } // nVars
+
+
+    if (!detailed) return expr;
+    retRationalize.coefficients = coefficients;
+    retRationalize.variables = polyRet.variables;
+    retRationalize.expression = expr;
+    return retRationalize;
+  }
+
+  return typed(name, {
+    Node: _rationalize,
+    'Node, boolean': (expr, detailed) => _rationalize(expr, {}, detailed),
+    'Node, Object': _rationalize,
+    'Node, Object, boolean': _rationalize
   }); // end of typed rationalize
 
   /**

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

@@ -1,10 +1,11 @@
-import { createMap, isMap } from '../../utils/map.js';
+import { createMap } 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', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+var dependencies = ['typed', 'parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
 export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
+    typed,
     parse,
     ConstantNode,
     FunctionNode,
@@ -21,9 +22,9 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * Examples:
    *
-   *     math.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
-   *     math.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
-   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
+   *     math.resolve('x + y', {x:1, y:2})           // Node '1 + 2'
+   *     math.resolve(math.parse('x+y'), {x:1, y:2}) // Node '1 + 2'
+   *     math.simplify('x+y', {x:2, y: math.parse('x+x')}).toString() // "6"
    *
    * See also:
    *
@@ -38,7 +39,7 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     If there is a cyclic dependency among the variables in `scope`,
    *     resolution is impossible and a ReferenceError is thrown.
    */
-  function resolve(node, scope) {
+  function _resolve(node, scope) {
     var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
 
     // note `within`:
@@ -48,10 +49,6 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
       return node;
     }
 
-    if (!isMap(scope)) {
-      scope = createMap(scope);
-    }
-
     if (isSymbolNode(node)) {
       if (within.has(node.name)) {
         var variables = Array.from(within).join(', ');
@@ -63,7 +60,7 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (isNode(value)) {
         var nextWithin = new Set(within);
         nextWithin.add(node.name);
-        return resolve(value, scope, nextWithin);
+        return _resolve(value, scope, nextWithin);
       } else if (typeof value === 'number') {
         return parse(String(value));
       } else if (value !== undefined) {
@@ -73,14 +70,14 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     } else if (isOperatorNode(node)) {
       var args = node.args.map(function (arg) {
-        return resolve(arg, scope, within);
+        return _resolve(arg, scope, within);
       });
       return new OperatorNode(node.op, node.fn, args, node.implicit);
     } else if (isParenthesisNode(node)) {
-      return new ParenthesisNode(resolve(node.content, scope, within));
+      return new ParenthesisNode(_resolve(node.content, scope, within));
     } else if (isFunctionNode(node)) {
       var _args = node.args.map(function (arg) {
-        return resolve(arg, scope, within);
+        return _resolve(arg, scope, within);
       });
 
       return new FunctionNode(node.name, _args);
@@ -88,8 +85,20 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
     // for some of the above special cases)
 
 
-    return node.map(child => resolve(child, scope, within));
+    return node.map(child => _resolve(child, scope, within));
   }
 
-  return resolve;
+  return typed('resolve', {
+    Node: _resolve,
+    'Node, Map | null | undefined': _resolve,
+    'Node, Object': (n, scope) => _resolve(n, createMap(scope)),
+    // For arrays and matrices, we map `self` rather than `_resolve`
+    // because resolve is fairly expensive anyway, and this way
+    // we get nice error messages if one entry in the array has wrong type.
+    'Array | Matrix': typed.referToSelf(self => A => A.map(n => self(n))),
+    'Array | Matrix, null | undefined': typed.referToSelf(self => A => A.map(n => self(n))),
+    'Array, Object': typed.referTo('Array,Map', selfAM => (A, scope) => selfAM(A, createMap(scope))),
+    'Matrix, Object': typed.referTo('Matrix,Map', selfMM => (A, scope) => selfMM(A, createMap(scope))),
+    'Array | Matrix, Map': typed.referToSelf(self => (A, scope) => A.map(n => self(n, scope)))
+  });
 });