mathjs 10.0.0 → 10.6.4

package/lib/esm/factoriesNumber.js

@@ -1,4 +1,4 @@
-import { absNumber, acoshNumber, acosNumber, acothNumber, acotNumber, acschNumber, acscNumber, addNumber, andNumber, asechNumber, asecNumber, asinhNumber, asinNumber, atan2Number, atanhNumber, atanNumber, bitAndNumber, bitNotNumber, bitOrNumber, bitXorNumber, cbrtNumber, ceilNumber, combinationsNumber, coshNumber, cosNumber, cothNumber, cotNumber, cschNumber, cscNumber, cubeNumber, divideNumber, expm1Number, expNumber, fixNumber, floorNumber, gammaNumber, gcdNumber, isIntegerNumber, isNaNNumber, isNegativeNumber, isPositiveNumber, isZeroNumber, lcmNumber, leftShiftNumber, log10Number, log1pNumber, log2Number, logNumber, modNumber, multiplyNumber, normNumber, notNumber, orNumber, powNumber, rightArithShiftNumber, rightLogShiftNumber, sechNumber, secNumber, signNumber, sinhNumber, sinNumber, sqrtNumber, squareNumber, subtractNumber, tanhNumber, tanNumber, unaryMinusNumber, unaryPlusNumber, xgcdNumber, xorNumber } from './plain/number/index.js';
+import { absNumber, acoshNumber, acosNumber, acothNumber, acotNumber, acschNumber, acscNumber, addNumber, andNumber, asechNumber, asecNumber, asinhNumber, asinNumber, atan2Number, atanhNumber, atanNumber, bitAndNumber, bitNotNumber, bitOrNumber, bitXorNumber, cbrtNumber, combinationsNumber, coshNumber, cosNumber, cothNumber, cotNumber, cschNumber, cscNumber, cubeNumber, divideNumber, expm1Number, expNumber, gammaNumber, gcdNumber, isIntegerNumber, isNaNNumber, isNegativeNumber, isPositiveNumber, isZeroNumber, lcmNumber, leftShiftNumber, lgammaNumber, log10Number, log1pNumber, log2Number, logNumber, modNumber, multiplyNumber, normNumber, notNumber, nthRootNumber, orNumber, powNumber, rightArithShiftNumber, rightLogShiftNumber, roundNumber, sechNumber, secNumber, signNumber, sinhNumber, sinNumber, sqrtNumber, squareNumber, subtractNumber, tanhNumber, tanNumber, unaryMinusNumber, unaryPlusNumber, xgcdNumber, xorNumber } from './plain/number/index.js';
 import { factory } from './utils/factory.js';
 import { noIndex, noMatrix, noSubset } from './utils/noop.js'; // ----------------------------------------------------------------------------
 // classes and functions
@@ -13,7 +13,9 @@ export { createChainClass } from './type/chain/Chain.js';
 export { createHelp } from './expression/function/help.js';
 export { createChain } from './type/chain/function/chain.js'; // algebra
 
+export { createResolve } from './function/algebra/resolve.js';
 export { createSimplify } from './function/algebra/simplify.js';
+export { createSimplifyCore } from './function/algebra/simplifyCore.js';
 export { createDerivative } from './function/algebra/derivative.js';
 export { createRationalize } from './function/algebra/rationalize.js'; // arithmetic
 
@@ -22,12 +24,12 @@ export var createUnaryPlus = /* #__PURE__ */createNumberFactory('unaryPlus', una
 export var createAbs = /* #__PURE__ */createNumberFactory('abs', absNumber);
 export var createAddScalar = /* #__PURE__ */createNumberFactory('addScalar', addNumber);
 export var createCbrt = /* #__PURE__ */createNumberFactory('cbrt', cbrtNumber);
-export var createCeil = /* #__PURE__ */createNumberFactory('ceil', ceilNumber);
+export { createCeilNumber as createCeil } from './function/arithmetic/ceil.js';
 export var createCube = /* #__PURE__ */createNumberFactory('cube', cubeNumber);
 export var createExp = /* #__PURE__ */createNumberFactory('exp', expNumber);
 export var createExpm1 = /* #__PURE__ */createNumberFactory('expm1', expm1Number);
-export var createFix = /* #__PURE__ */createNumberFactory('fix', fixNumber);
-export var createFloor = /* #__PURE__ */createNumberFactory('floor', floorNumber);
+export { createFixNumber as createFix } from './function/arithmetic/fix.js';
+export { createFloorNumber as createFloor } from './function/arithmetic/floor.js';
 export var createGcd = /* #__PURE__ */createNumberFactory('gcd', gcdNumber);
 export var createLcm = /* #__PURE__ */createNumberFactory('lcm', lcmNumber);
 export var createLog10 = /* #__PURE__ */createNumberFactory('log10', log10Number);
@@ -35,7 +37,7 @@ export var createLog2 = /* #__PURE__ */createNumberFactory('log2', log2Number);
 export var createMod = /* #__PURE__ */createNumberFactory('mod', modNumber);
 export var createMultiplyScalar = /* #__PURE__ */createNumberFactory('multiplyScalar', multiplyNumber);
 export var createMultiply = /* #__PURE__ */createNumberFactory('multiply', multiplyNumber);
-export { createNthRootNumber as createNthRoot } from './function/arithmetic/nthRoot.js';
+export var createNthRoot = /* #__PURE__ */createNumberOptionalSecondArgFactory('nthRoot', nthRootNumber);
 export var createSign = /* #__PURE__ */createNumberFactory('sign', signNumber);
 export var createSqrt = /* #__PURE__ */createNumberFactory('sqrt', sqrtNumber);
 export var createSquare = /* #__PURE__ */createNumberFactory('square', squareNumber);
@@ -43,8 +45,8 @@ export var createSubtract = /* #__PURE__ */createNumberFactory('subtract', subtr
 export var createXgcd = /* #__PURE__ */createNumberFactory('xgcd', xgcdNumber);
 export var createDivideScalar = /* #__PURE__ */createNumberFactory('divideScalar', divideNumber);
 export var createPow = /* #__PURE__ */createNumberFactory('pow', powNumber);
-export { createRoundNumber as createRound } from './function/arithmetic/round.js';
-export var createLog = /* #__PURE__ */createNumberFactory('log', logNumber);
+export var createRound = /* #__PURE__ */createNumberOptionalSecondArgFactory('round', roundNumber);
+export var createLog = /* #__PURE__ */createNumberOptionalSecondArgFactory('log', logNumber);
 export var createLog1p = /* #__PURE__ */createNumberFactory('log1p', log1pNumber);
 export var createAdd = /* #__PURE__ */createNumberFactory('add', addNumber);
 export { createHypot } from './function/arithmetic/hypot.js';
@@ -116,6 +118,7 @@ export { createPartitionSelect } from './function/matrix/partitionSelect.js'; //
 
 export var createCombinations = createNumberFactory('combinations', combinationsNumber);
 export var createGamma = createNumberFactory('gamma', gammaNumber);
+export var createLgamma = createNumberFactory('lgamma', lgammaNumber);
 export { createCombinationsWithRep } from './function/probability/combinationsWithRep.js';
 export { createFactorial } from './function/probability/factorial.js';
 export { createMultinomial } from './function/probability/multinomial.js';
@@ -144,6 +147,7 @@ export { createProd } from './function/statistics/prod.js';
 export { createMax } from './function/statistics/max.js';
 export { createMin } from './function/statistics/min.js';
 export { createSum } from './function/statistics/sum.js';
+export { createCumSum } from './function/statistics/cumsum.js';
 export { createMean } from './function/statistics/mean.js';
 export { createMedian } from './function/statistics/median.js';
 export { createMad } from './function/statistics/mad.js';
@@ -193,6 +197,7 @@ export var createSubsetTransform = /* #__PURE__ */factory('subset', [], () => no
 });
 export { createStdTransform } from './expression/transform/std.transform.js';
 export { createSumTransform } from './expression/transform/sum.transform.js';
+export { createCumSumTransform } from './expression/transform/cumsum.transform.js';
 export { createVarianceTransform } from './expression/transform/variance.transform.js'; // utils
 
 export { createClone } from './function/utils/clone.js';
@@ -208,7 +213,7 @@ export { createIsPrime } from './function/utils/isPrime.js';
 export { createNumeric } from './function/utils/numeric.js'; // json
 
 export { createReviver } from './json/reviver.js';
-export { createReplacer } from './json/replacer.js'; // helper function to create a factory function for a function which only needs typed-function
+export { createReplacer } from './json/replacer.js'; // helper functions to create a factory function for a function which only needs typed-function
 
 function createNumberFactory(name, fn) {
   return factory(name, ['typed'], _ref => {
@@ -217,4 +222,16 @@ function createNumberFactory(name, fn) {
     } = _ref;
     return typed(fn);
   });
+}
+
+function createNumberOptionalSecondArgFactory(name, fn) {
+  return factory(name, ['typed'], _ref2 => {
+    var {
+      typed
+    } = _ref2;
+    return typed({
+      number: fn,
+      'number,number': fn
+    });
+  });
 }

package/lib/esm/function/algebra/decomposition/qr.js

@@ -204,8 +204,8 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
 
 
     return {
-      Q: Q,
-      R: R,
+      Q,
+      R,
       toString: function toString() {
         return 'Q: ' + this.Q.toString() + '\nR: ' + this.R.toString();
       }

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

@@ -115,7 +115,7 @@ export var createDerivative = /* #__PURE__ */factory(name, dependencies, _ref =>
       if (isConstantNode(expr) && typeOf(expr.value) === 'string') {
         return _derivTex(parse(expr.value).toString(), x.toString(), 1);
       } else {
-        return _derivTex(expr.toString(), x.toString(), 1);
+        return _derivTex(expr.toTex(), x.toString(), 1);
       }
     },
     'Node, ConstantNode': function NodeConstantNode(expr, x) {

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

@@ -0,0 +1,59 @@
+import { factory } from '../../utils/factory.js';
+var name = 'leafCount';
+var dependencies = ['parse', 'typed'];
+export var createLeafCount = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    typed
+  } = _ref;
+
+  // This does the real work, but we don't have to recurse through
+  // a typed call if we separate it out
+  function countLeaves(node) {
+    var count = 0;
+    node.forEach(n => {
+      count += countLeaves(n);
+    });
+    return count || 1;
+  }
+  /**
+   * Gives the number of "leaf nodes" in the parse tree of the given expression
+   * A leaf node is one that has no subexpressions, essentially either a
+   * symbol or a constant. Note that `5!` has just one leaf, the '5'; the
+   * unary factorial operator does not add a leaf. On the other hand,
+   * function symbols do add leaves, so `sin(x)/cos(x)` has four leaves.
+   *
+   * The `simplify()` function should generally not increase the `leafCount()`
+   * of an expression, although currently there is no guarantee that it never
+   * does so. In many cases, `simplify()` reduces the leaf count.
+   *
+   * Syntax:
+   *
+   *     leafCount(expr)
+   *
+   * Examples:
+   *
+   *     math.leafCount('x') // 1
+   *     math.leafCount(math.parse('a*d-b*c')) // 4
+   *     math.leafCount('[a,b;c,d][0,1]') // 6
+   *
+   * See also:
+   *
+   *     simplify
+   *
+   * @param {Node|string} expr    The expression to count the leaves of
+   *
+   * @return {number}  The number of leaves of `expr`
+   *
+   */
+
+
+  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,9 +1,8 @@
 import { isInteger } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 import { createSimplifyConstant } from './simplify/simplifyConstant.js';
-import { createSimplifyCore } from './simplify/simplifyCore.js';
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'SymbolNode', 'ParenthesisNode'];
+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'];
 export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
@@ -16,13 +15,19 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     divide,
     pow,
     parse,
+    simplifyCore,
     simplify,
     fraction,
     bignumber,
     mathWithTransform,
+    matrix,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode,
     ParenthesisNode
   } = _ref;
@@ -30,25 +35,17 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
-    SymbolNode
-  });
-  var simplifyCore = createSimplifyCore({
-    equal,
-    isZero,
-    add,
-    subtract,
-    multiply,
-    divide,
-    pow,
-    ConstantNode,
+    IndexNode,
+    ObjectNode,
     OperatorNode,
-    FunctionNode,
-    ParenthesisNode
+    SymbolNode
   });
   /**
    * Transform a rationalizable expression in a rational fraction.
@@ -93,13 +90,13 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
    * @param  {Object|boolean}      optional scope of expression or true for already evaluated rational expression at input
    * @param  {Boolean}  detailed   optional True if return an object, false if return expression node (default)
    *
-   * @return {Object | Node}    The rational polynomial of `expr` or na object
-   *            {Object}
-   *              {Expression Node} expression: node simplified expression
-   *              {Expression Node} numerator: simplified numerator of expression
-   *              {Expression Node | boolean} denominator: simplified denominator or false (if there is no denominator)
-   *              {Array}           variables:  variable names
-   *              {Array}           coefficients: coefficients of numerator sorted by increased exponent
+   * @return {Object | Node}    The rational polynomial of `expr` or an object
+   *            `{expression, numerator, denominator, variables, coefficients}`, where
+   *              `expression` is a `Node` with the node simplified expression,
+   *              `numerator` is a `Node` with the simplified numerator of expression,
+   *              `denominator` is a `Node` or `boolean` with the simplified denominator or `false` (if there is no denominator),
+   *              `variables` is an array with variable names,
+   *              and `coefficients` is an array with coefficients of numerator sorted by increased exponent
    *           {Expression Node}  node simplified expression
    *
    */
@@ -132,6 +129,12 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
       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) {
@@ -142,18 +145,16 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
 
         var rules;
         var eDistrDiv = true;
-        var redoInic = false;
-        expr = simplify(expr, setRules.firstRules, {}, {
-          exactFractions: false
-        }); // Apply the initial rules, including succ div rules
+        var redoInic = false; // Apply the initial rules, including succ div rules:
 
+        expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
         var s;
 
         while (true) {
-          // Apply alternately  successive division rules and distr.div.rules
+          // 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); // until no more changes
-
+          expr = simplify(expr, rules, {}, withExactFractions);
           eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
 
           s = expr.toString();
@@ -168,14 +169,11 @@ export var createRationalize = /* #__PURE__ */factory(name, dependencies, _ref =
 
         if (redoInic) {
           // Apply first rules again without succ div rules (if there are changes)
-          expr = simplify(expr, setRules.firstRulesAgain, {}, {
-            exactFractions: false
-          });
-        }
+          expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
+        } // Apply final rules:
+
 
-        expr = simplify(expr, setRules.finalRules, {}, {
-          exactFractions: false
-        }); // Apply final rules
+        expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
       } // NVars >= 1
 
 

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

@@ -0,0 +1,95 @@
+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', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    ConstantNode,
+    FunctionNode,
+    OperatorNode,
+    ParenthesisNode
+  } = _ref;
+
+  /**
+   * resolve(expr, scope) replaces variable nodes with their scoped values
+   *
+   * Syntax:
+   *
+   *     resolve(expr, scope)
+   *
+   * 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"
+   *
+   * See also:
+   *
+   *     simplify, evaluate
+   *
+   * @param {Node | Node[]} node
+   *     The expression tree (or trees) to be simplified
+   * @param {Object} scope
+   *     Scope specifying variables to be resolved
+   * @return {Node | Node[]} Returns `node` with variables recursively substituted.
+   * @throws {ReferenceError}
+   *     If there is a cyclic dependency among the variables in `scope`,
+   *     resolution is impossible and a ReferenceError is thrown.
+   */
+  function resolve(node, scope) {
+    var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+
+    // note `within`:
+    // `within` is not documented, since it is for internal cycle
+    // detection only
+    if (!scope) {
+      return node;
+    }
+
+    if (!isMap(scope)) {
+      scope = createMap(scope);
+    }
+
+    if (isSymbolNode(node)) {
+      if (within.has(node.name)) {
+        var variables = Array.from(within).join(', ');
+        throw new ReferenceError("recursive loop of variable definitions among {".concat(variables, "}"));
+      }
+
+      var value = scope.get(node.name);
+
+      if (isNode(value)) {
+        var nextWithin = new Set(within);
+        nextWithin.add(node.name);
+        return resolve(value, scope, nextWithin);
+      } else if (typeof value === 'number') {
+        return parse(String(value));
+      } else if (value !== undefined) {
+        return new ConstantNode(value);
+      } else {
+        return node;
+      }
+    } else if (isOperatorNode(node)) {
+      var args = node.args.map(function (arg) {
+        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));
+    } else if (isFunctionNode(node)) {
+      var _args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+
+      return new FunctionNode(node.name, _args);
+    } // Otherwise just recursively resolve any children (might also work
+    // for some of the above special cases)
+
+
+    return node.map(child => resolve(child, scope, within));
+  }
+
+  return resolve;
+});