mathjs 10.0.0 → 10.1.1

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

@@ -7,7 +7,7 @@ import { createResolve } from './simplify/resolve.js';
 import { hasOwnProperty } from '../../utils/object.js';
 import { createEmptyMap, createMap } from '../../utils/map.js';
 var name = 'simplify';
-var dependencies = ['config', 'typed', 'parse', 'add', 'subtract', 'multiply', 'divide', 'pow', 'isZero', 'equal', '?fraction', '?bignumber', 'mathWithTransform', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+var dependencies = ['config', 'typed', 'parse', 'add', 'subtract', 'multiply', 'divide', 'pow', 'isZero', 'equal', '?fraction', '?bignumber', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
@@ -23,8 +23,13 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     fraction,
     bignumber,
     mathWithTransform,
+    matrix,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
     OperatorNode,
     ParenthesisNode,
     SymbolNode
@@ -33,11 +38,16 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode
   });
   var simplifyCore = createSimplifyCore({
@@ -48,9 +58,13 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     ParenthesisNode
   });
   var resolve = createResolve({
@@ -107,11 +121,14 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
    * - [Symbolic computation - Simplification (Wikipedia)](https://en.wikipedia.org/wiki/Symbolic_computation#Simplification)
    *
    *  An optional `options` argument can be passed as last argument of `simplify`.
-   *  There is currently one option available:
-   *  - `exactFractions`: a boolean which is `true` by default.
-   *  - `fractionsLimit`: when `exactFractions` is true, a fraction will be returned
-   *    only when both numerator and denominator are smaller than `fractionsLimit`.
-   *    Default value is 10000.
+   *  Currently available options (defaults in parentheses):
+   *  - `consoleDebug` (false): whether to write the expression being simplified
+        and any changes to it, along with the rule responsible, to console
+   *  - `exactFractions` (true): whether to try to convert all constants to
+        exact rational numbers.
+   *  - `fractionsLimit` (10000): when `exactFractions` is true, constants will
+        be expressed as fractions only when both numerator and denominator
+        are smaller than `fractionsLimit`.
    *
    * Syntax:
    *
@@ -181,6 +198,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       return this(expr, rules, createMap(scope), options);
     },
     'Node, Array, Map, Object': function NodeArrayMapObject(expr, rules, scope, options) {
+      var debug = options.consoleDebug;
       rules = _buildRules(rules);
       var res = resolve(expr, scope);
       res = removeParens(res);
@@ -193,12 +211,33 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
         visited[str] = true;
         _lastsym = 0; // counter for placeholder symbols
 
+        var laststr = str;
+        if (debug) console.log('Working on: ', str);
+
         for (var i = 0; i < rules.length; i++) {
+          var rulestr = '';
+
           if (typeof rules[i] === 'function') {
             res = rules[i](res, options);
+            if (debug) rulestr = rules[i].name;
           } else {
             flatten(res);
             res = applyRule(res, rules[i]);
+
+            if (debug) {
+              rulestr = "".concat(rules[i].l.toString(), " -> ").concat(rules[i].r.toString());
+            }
+          }
+
+          if (debug) {
+            var newstr = res.toString({
+              parenthesis: 'all'
+            });
+
+            if (newstr !== laststr) {
+              console.log('Applying', rulestr, 'produced', newstr);
+              laststr = newstr;
+            }
           }
 
           unflattenl(res); // using left-heavy binary tree here since custom rule functions may expect it
@@ -262,17 +301,19 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     l: 'log(e)',
     r: '1'
   }, // temporary rules
+  // Note initially we tend constants to the right because like-term
+  // collection prefers the left, and we would rather collect nonconstants
   {
     l: 'n-n1',
     r: 'n+-n1'
   }, // temporarily replace 'subtract' so we can further flatten the 'add' operator
   {
     l: '-(c*v)',
-    r: '(-c) * v'
+    r: 'v * (-c)'
   }, // make non-constant terms positive
   {
     l: '-v',
-    r: '(-1) * v'
+    r: 'v * (-1)'
   }, {
     l: 'n/n1^n2',
     r: 'n*n1^-n2'
@@ -280,7 +321,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   {
     l: 'n/n1',
     r: 'n*n1^-1'
-  }, // expand nested exponentiation
+  }, simplifyConstant, // expand nested exponentiation
   {
     l: '(n ^ n1) ^ n2',
     r: 'n ^ (n1 * n2)'
@@ -302,20 +343,29 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     l: 'n+-n',
     r: '0'
   }, {
-    l: 'n1*n2 + n2',
-    r: '(n1+1)*n2'
-  }, {
-    l: 'n1*n3 + n2*n3',
-    r: '(n1+n2)*n3'
-  }, // remove parenthesis in the case of negating a quantitiy
+    l: 'v*n + v',
+    r: 'v*(n+1)'
+  }, // NOTE: leftmost position is special:
+  {
+    l: 'n3*n1 + n3*n2',
+    r: 'n3*(n1+n2)'
+  }, // All sub-monomials tried there.
+  {
+    l: 'n*c + c',
+    r: '(n+1)*c'
+  }, // remove parenthesis in the case of negating a quantity
+  // (It might seem this rule should precede collecting like terms,
+  // but putting it after gives another chance of noticing like terms,
+  // and any new like terms produced by this will be collected
+  // on the next pass through all the rules.)
+  {
+    l: 'n1 + (n2 + n3)*(-1)',
+    r: 'n1 + n2*(-1) + n3*(-1)'
+  }, // make factors positive (and undo 'make non-constant terms positive')
   {
-    l: 'n1 + -1 * (n2 + n3)',
-    r: 'n1 + -1 * n2 + -1 * n3'
-  }, simplifyConstant, {
     l: '(-n)*n1',
     r: '-(n*n1)'
-  }, // make factors positive (and undo 'make non-constant terms positive')
-  // ordering of constants
+  }, // final ordering of constants
   {
     l: 'c+v',
     r: 'v+c',
@@ -365,6 +415,9 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   {
     l: 'n1/(n2/n3)',
     r: '(n1*n3)/n2'
+  }, {
+    l: 'n1/(-n2)',
+    r: '-n1/n2'
   }];
   /**
    * Parse the string array of rules into nodes
@@ -416,7 +469,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
           };
 
           if (rule.context) {
-            newRule.evaluate = rule.context;
+            newRule.context = rule.context;
           }
 
           if (rule.evaluate) {
@@ -460,6 +513,14 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   function _getExpandPlaceholderSymbol() {
     return new SymbolNode('_p' + _lastsym++);
   }
+
+  function mapRule(nodes, rule) {
+    if (nodes) {
+      for (var i = 0; i < nodes.length; ++i) {
+        nodes[i] = applyRule(nodes[i], rule);
+      }
+    }
+  }
   /**
    * Returns a simplfied form of node, or the original node if no simplification was possible.
    *
@@ -473,19 +534,31 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
       // console.log('Entering applyRule(' + node.toString() + ')')
       // Do not clone node unless we find a match
       var res = node; // First replace our child nodes with their simplified versions
-      // If a child could not be simplified, the assignments will have
-      // no effect since the node is returned unchanged
+      // If a child could not be simplified, applying the rule to it
+      // will have no effect since the node is returned unchanged
 
       if (res instanceof OperatorNode || res instanceof FunctionNode) {
-        if (res.args) {
-          for (var i = 0; i < res.args.length; i++) {
-            res.args[i] = applyRule(res.args[i], rule);
-          }
-        }
+        mapRule(res.args, rule);
       } else if (res instanceof ParenthesisNode) {
         if (res.content) {
           res.content = applyRule(res.content, rule);
         }
+      } else if (res instanceof ArrayNode) {
+        mapRule(res.items, rule);
+      } else if (res instanceof AccessorNode) {
+        if (res.object) {
+          res.object = applyRule(res.object, rule);
+        }
+
+        if (res.index) {
+          res.index = applyRule(res.index, rule);
+        }
+      } else if (res instanceof IndexNode) {
+        mapRule(res.dimensions, rule);
+      } else if (res instanceof ObjectNode) {
+        for (var prop in res.properties) {
+          res.properties[prop] = applyRule(res.properties[prop], rule);
+        }
       } // Try to match a rule against this node
 
 

package/lib/esm/function/arithmetic/invmod.js

@@ -0,0 +1,57 @@
+import { factory } from '../../utils/factory.js';
+var name = 'invmod';
+var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+export var createInvmod = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    BigNumber,
+    xgcd,
+    equal,
+    smaller,
+    mod,
+    add,
+    isInteger
+  } = _ref;
+
+  /**
+   * Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
+   * See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
+   *
+   * Syntax:
+   *
+   *    math.invmod(a, b)
+   *
+   * Examples:
+   *
+   *    math.invmod(8, 12)             // returns NaN
+   *    math.invmod(7, 13)             // return 2
+   *    math.invmod(15151, 15122)      // returns 10429
+   *
+   * See also:
+   *
+   *    gcd, xgcd
+   *
+   * @param {number | BigNumber} a  An integer number
+   * @param {number | BigNumber} b  An integer number
+   * @return {number | BigNumber }  Returns an integer number
+   *                              where `invmod(a,b)*a ≣ 1 (mod b)`
+   */
+  return typed(name, {
+    'number, number': invmod,
+    'BigNumber, BigNumber': invmod
+  });
+
+  function invmod(a, b) {
+    if (!isInteger(a) || !isInteger(b)) throw new Error('Parameters in function invmod must be integer numbers');
+    a = mod(a, b);
+    if (equal(b, 0)) throw new Error('Divisor must be non zero');
+    var res = xgcd(a, b);
+    res = res.valueOf();
+    var [gcd, inv] = res;
+    if (!equal(gcd, BigNumber(1))) return NaN;
+    inv = mod(inv, b);
+    if (smaller(inv, BigNumber(0))) inv = add(inv, b);
+    return inv;
+  }
+});

package/lib/esm/function/arithmetic/round.js

@@ -1,8 +1,8 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';

package/lib/esm/function/geometry/intersect.js

@@ -1,7 +1,6 @@
-import { isBigNumber } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'intersect';
-var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten'];
+var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten', 'isZero', 'isNumeric'];
 export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -16,7 +15,9 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     subtract,
     smaller,
     equalScalar,
-    flatten
+    flatten,
+    isZero,
+    isNumeric
   } = _ref;
 
   /**
@@ -142,21 +143,16 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     return arr;
   }
 
-  function _isNumeric(a) {
-    // intersect supports numbers and bignumbers
-    return typeof a === 'number' || isBigNumber(a);
-  }
-
   function _2d(x) {
-    return x.length === 2 && _isNumeric(x[0]) && _isNumeric(x[1]);
+    return x.length === 2 && isNumeric(x[0]) && isNumeric(x[1]);
   }
 
   function _3d(x) {
-    return x.length === 3 && _isNumeric(x[0]) && _isNumeric(x[1]) && _isNumeric(x[2]);
+    return x.length === 3 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]);
   }
 
   function _4d(x) {
-    return x.length === 4 && _isNumeric(x[0]) && _isNumeric(x[1]) && _isNumeric(x[2]) && _isNumeric(x[3]);
+    return x.length === 4 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]) && isNumeric(x[3]);
   }
 
   function _intersect2d(p1a, p1b, p2a, p2b) {
@@ -165,6 +161,7 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     var d1 = subtract(o1, p1b);
     var d2 = subtract(o2, p2b);
     var det = subtract(multiplyScalar(d1[0], d2[1]), multiplyScalar(d2[0], d1[1]));
+    if (isZero(det)) return null;
 
     if (smaller(abs(det), config.epsilon)) {
       return null;
@@ -197,7 +194,10 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
 
     var d2121 = _intersect3dHelper(x2, x1, x2, x1, y2, y1, y2, y1, z2, z1, z2, z1);
 
-    var ta = divideScalar(subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343)), subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321)));
+    var numerator = subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343));
+    var denominator = subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321));
+    if (isZero(denominator)) return null;
+    var ta = divideScalar(numerator, denominator);
     var tb = divideScalar(addScalar(d1343, multiplyScalar(ta, d4321)), d4343);
     var pax = addScalar(x1, multiplyScalar(ta, subtract(x2, x1)));
     var pay = addScalar(y1, multiplyScalar(ta, subtract(y2, y1)));

package/lib/esm/function/probability/gamma.js

@@ -41,44 +41,42 @@ export var createGamma = /* #__PURE__ */factory(name, dependencies, _ref => {
     Complex: function Complex(n) {
       if (n.im === 0) {
         return this(n.re);
-      }
+      } // Lanczos approximation doesn't work well with real part lower than 0.5
+      // So reflection formula is required
+
+
+      if (n.re < 0.5) {
+        // Euler's reflection formula
+        // gamma(1-z) * gamma(z) = PI / sin(PI * z)
+        // real part of Z should not be integer [sin(PI) == 0 -> 1/0 - undefined]
+        // thanks to imperfect sin implementation sin(PI * n) != 0
+        // we can safely use it anyway
+        var _t = new _Complex(1 - n.re, -n.im);
+
+        var r = new _Complex(Math.PI * n.re, Math.PI * n.im);
+        return new _Complex(Math.PI).div(r.sin()).div(this(_t));
+      } // Lanczos approximation
+      // z -= 1
+
 
-      n = new _Complex(n.re - 1, n.im);
-      var x = new _Complex(gammaP[0], 0);
+      n = new _Complex(n.re - 1, n.im); // x = gammaPval[0]
+
+      var x = new _Complex(gammaP[0], 0); // for (i, gammaPval) in enumerate(gammaP):
 
       for (var i = 1; i < gammaP.length; ++i) {
-        var real = n.re + i; // x += p[i]/(n+i)
+        // x += gammaPval / (z + i)
+        var gammaPval = new _Complex(gammaP[i], 0);
+        x = x.add(gammaPval.div(n.add(i)));
+      } // t = z + gammaG + 0.5
 
-        var den = real * real + n.im * n.im;
 
-        if (den !== 0) {
-          x.re += gammaP[i] * real / den;
-          x.im += -(gammaP[i] * n.im) / den;
-        } else {
-          x.re = gammaP[i] < 0 ? -Infinity : Infinity;
-        }
-      }
+      var t = new _Complex(n.re + gammaG + 0.5, n.im); // y = sqrt(2 * pi) * t ** (z + 0.5) * exp(-t) * x
 
-      var t = new _Complex(n.re + gammaG + 0.5, n.im);
       var twoPiSqrt = Math.sqrt(2 * Math.PI);
-      n.re += 0.5;
-      var result = pow(t, n);
-
-      if (result.im === 0) {
-        // sqrt(2*PI)*result
-        result.re *= twoPiSqrt;
-      } else if (result.re === 0) {
-        result.im *= twoPiSqrt;
-      } else {
-        result.re *= twoPiSqrt;
-        result.im *= twoPiSqrt;
-      }
-
-      var r = Math.exp(-t.re); // exp(-t)
+      var tpow = t.pow(n.add(0.5));
+      var expt = t.neg().exp(); // y = [x] * [sqrt(2 * pi)] * [t ** (z + 0.5)] * [exp(-t)]
 
-      t.re = r * Math.cos(-t.im);
-      t.im = r * Math.sin(-t.im);
-      return multiplyScalar(multiplyScalar(result, t), x);
+      return x.mul(twoPiSqrt).mul(tpow).mul(expt);
     },
     BigNumber: function BigNumber(n) {
       if (n.isInteger()) {

package/lib/esm/header.js

@@ -10,7 +10,7 @@
  * @date    @@date
  *
  * @license
- * Copyright (C) 2013-2021 Jos de Jong <wjosdejong@gmail.com>
+ * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy

package/lib/esm/type/matrix/SparseMatrix.js

@@ -417,23 +417,27 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
 
       if (!deepStrictEqual(iSize, sSize)) {
         throw new DimensionError(iSize, sSize, '>');
-      } // offsets
+      } // insert the sub matrix
 
 
-      var x0 = index.min()[0];
-      var y0 = index.min()[1]; // submatrix rows and columns
-
-      var m = sSize[0];
-      var n = sSize[1]; // loop submatrix
-
-      for (var x = 0; x < m; x++) {
-        // loop columns
-        for (var y = 0; y < n; y++) {
-          // value at i, j
-          var v = submatrix[x][y]; // invoke set (zero value will remove entry from matrix)
-
-          matrix.set([x + x0, y + y0], v, defaultValue);
-        }
+      if (iSize.length === 1) {
+        // if the replacement index only has 1 dimension, go trough each one and set its value
+        var range = index.dimension(0);
+        range.forEach(function (dataIndex, subIndex) {
+          validateIndex(dataIndex);
+          matrix.set([dataIndex, 0], submatrix[subIndex[0]], defaultValue);
+        });
+      } else {
+        // if the replacement index has 2 dimensions, go through each one and set the value in the correct index
+        var firstDimensionRange = index.dimension(0);
+        var secondDimensionRange = index.dimension(1);
+        firstDimensionRange.forEach(function (firstDataIndex, firstSubIndex) {
+          validateIndex(firstDataIndex);
+          secondDimensionRange.forEach(function (secondDataIndex, secondSubIndex) {
+            validateIndex(secondDataIndex);
+            matrix.set([firstDataIndex, secondDataIndex], submatrix[firstSubIndex[0]][secondSubIndex[0]], defaultValue);
+          });
+        });
       }
     }
 

package/lib/esm/type/unit/Unit.js

@@ -1,9 +1,9 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import { isComplex, isUnit, typeOf } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';

package/lib/esm/utils/number.js

@@ -318,7 +318,7 @@ export function format(value, options) {
 
 export function splitNumber(value) {
   // parse the input value
-  var match = String(value).toLowerCase().match(/^0*?(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
+  var match = String(value).toLowerCase().match(/^(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
 
   if (!match) {
     throw new SyntaxError('Invalid number ' + value);

package/lib/esm/utils/snapshot.js

@@ -1,9 +1,9 @@
 import _extends from "@babel/runtime/helpers/extends";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 /**
  * This file contains helper methods to create expected snapshot structures

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '10.0.0'; // Note: This file is automatically generated when building math.js.
+export var version = '10.1.1'; // 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.0.0",
+  "version": "10.1.1",
   "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,43 +25,43 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.16.0",
+    "@babel/runtime": "^7.16.7",
     "complex.js": "^2.0.15",
     "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.1.1",
+    "fraction.js": "^4.1.2",
     "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.0",
-    "@babel/plugin-transform-object-assign": "7.16.0",
-    "@babel/plugin-transform-runtime": "7.16.0",
-    "@babel/preset-env": "7.16.0",
-    "@babel/register": "7.16.0",
+    "@babel/core": "7.16.12",
+    "@babel/plugin-transform-object-assign": "7.16.7",
+    "@babel/plugin-transform-runtime": "7.16.10",
+    "@babel/preset-env": "7.16.11",
+    "@babel/register": "7.16.9",
     "babel-loader": "8.2.3",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.19.1",
+    "core-js": "3.21.0",
     "del": "6.0.0",
-    "dtslint": "4.2.0",
+    "dtslint": "4.2.1",
     "expr-eval": "2.0.2",
-    "fancy-log": "1.3.3",
+    "fancy-log": "2.0.0",
     "glob": "7.2.0",
     "gulp": "4.0.2",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
     "jsep": "1.2.0",
-    "karma": "6.3.7",
+    "karma": "6.3.13",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "4.0.2",
-    "math-expression-evaluator": "1.3.8",
+    "math-expression-evaluator": "1.3.14",
     "mkdirp": "1.0.4",
     "mocha": "8.4.0",
     "ndarray": "1.0.19",
@@ -74,7 +74,7 @@
     "pad-right": "0.2.2",
     "standard": "16.0.4",
     "sylvester": "0.0.21",
-    "typescript": "4.4.4",
+    "typescript": "4.5.5",
     "webpack": "4.46.0",
     "zeros": "1.0.0"
   },
@@ -131,6 +131,7 @@
     "compile": "gulp --gulpfile gulpfile.cjs compile",
     "watch": "gulp --gulpfile gulpfile.cjs watch",
     "lint": "standard --env=mocha --env=worker",
+    "format": "npm run lint -- --fix",
     "validate:ascii": "gulp --gulpfile gulpfile.cjs validate:ascii",
     "test": "npm run test:src && npm run lint",
     "test:src": "mocha test/unit-tests",