mathjs 8.1.0 → 12.2.1

package/lib/cjs/utils/is.js

@@ -1,50 +1,51 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isNumber = isNumber;
-exports.isBigNumber = isBigNumber;
-exports.isComplex = isComplex;
-exports.isFraction = isFraction;
-exports.isUnit = isUnit;
-exports.isString = isString;
-exports.isMatrix = isMatrix;
-exports.isCollection = isCollection;
-exports.isDenseMatrix = isDenseMatrix;
-exports.isSparseMatrix = isSparseMatrix;
-exports.isRange = isRange;
-exports.isIndex = isIndex;
-exports.isBoolean = isBoolean;
-exports.isResultSet = isResultSet;
-exports.isHelp = isHelp;
-exports.isFunction = isFunction;
-exports.isDate = isDate;
-exports.isRegExp = isRegExp;
-exports.isObject = isObject;
-exports.isNull = isNull;
-exports.isUndefined = isUndefined;
 exports.isAccessorNode = isAccessorNode;
+exports.isArray = void 0;
 exports.isArrayNode = isArrayNode;
 exports.isAssignmentNode = isAssignmentNode;
+exports.isBigNumber = isBigNumber;
 exports.isBlockNode = isBlockNode;
+exports.isBoolean = isBoolean;
+exports.isChain = isChain;
+exports.isCollection = isCollection;
+exports.isComplex = isComplex;
 exports.isConditionalNode = isConditionalNode;
 exports.isConstantNode = isConstantNode;
+exports.isDate = isDate;
+exports.isDenseMatrix = isDenseMatrix;
+exports.isFraction = isFraction;
+exports.isFunction = isFunction;
 exports.isFunctionAssignmentNode = isFunctionAssignmentNode;
 exports.isFunctionNode = isFunctionNode;
+exports.isHelp = isHelp;
+exports.isIndex = isIndex;
 exports.isIndexNode = isIndexNode;
+exports.isMatrix = isMatrix;
 exports.isNode = isNode;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
 exports.isObjectNode = isObjectNode;
 exports.isOperatorNode = isOperatorNode;
 exports.isParenthesisNode = isParenthesisNode;
+exports.isRange = isRange;
 exports.isRangeNode = isRangeNode;
+exports.isRegExp = isRegExp;
+exports.isRelationalNode = isRelationalNode;
+exports.isResultSet = isResultSet;
+exports.isSparseMatrix = isSparseMatrix;
+exports.isString = isString;
 exports.isSymbolNode = isSymbolNode;
-exports.isChain = isChain;
+exports.isUndefined = isUndefined;
+exports.isUnit = isUnit;
+exports.rule2Node = rule2Node;
 exports.typeOf = typeOf;
-exports.isArray = void 0;
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 // type checks for all known types
 //
 // note that:
@@ -58,187 +59,158 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
 // - It must not be possible to override the type checks used internally,
 //   for security reasons, so these functions are not exposed in the expression
 //   parser.
+
 function isNumber(x) {
   return typeof x === 'number';
 }
-
 function isBigNumber(x) {
-  return x && x.constructor.prototype.isBigNumber === true || false;
+  if (!x || (0, _typeof2["default"])(x) !== 'object' || typeof x.constructor !== 'function') {
+    return false;
+  }
+  if (x.isBigNumber === true && (0, _typeof2["default"])(x.constructor.prototype) === 'object' && x.constructor.prototype.isBigNumber === true) {
+    return true;
+  }
+  if (typeof x.constructor.isDecimal === 'function' && x.constructor.isDecimal(x) === true) {
+    return true;
+  }
+  return false;
 }
-
 function isComplex(x) {
-  return x && _typeof(x) === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
+  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
 }
-
 function isFraction(x) {
-  return x && _typeof(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
+  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
 }
-
 function isUnit(x) {
   return x && x.constructor.prototype.isUnit === true || false;
 }
-
 function isString(x) {
   return typeof x === 'string';
 }
-
-var isArray = Array.isArray;
-exports.isArray = isArray;
-
+var isArray = exports.isArray = Array.isArray;
 function isMatrix(x) {
   return x && x.constructor.prototype.isMatrix === true || false;
 }
+
 /**
  * Test whether a value is a collection: an Array or Matrix
  * @param {*} x
  * @returns {boolean} isCollection
  */
-
-
 function isCollection(x) {
   return Array.isArray(x) || isMatrix(x);
 }
-
 function isDenseMatrix(x) {
   return x && x.isDenseMatrix && x.constructor.prototype.isMatrix === true || false;
 }
-
 function isSparseMatrix(x) {
   return x && x.isSparseMatrix && x.constructor.prototype.isMatrix === true || false;
 }
-
 function isRange(x) {
   return x && x.constructor.prototype.isRange === true || false;
 }
-
 function isIndex(x) {
   return x && x.constructor.prototype.isIndex === true || false;
 }
-
 function isBoolean(x) {
   return typeof x === 'boolean';
 }
-
 function isResultSet(x) {
   return x && x.constructor.prototype.isResultSet === true || false;
 }
-
 function isHelp(x) {
   return x && x.constructor.prototype.isHelp === true || false;
 }
-
 function isFunction(x) {
   return typeof x === 'function';
 }
-
 function isDate(x) {
   return x instanceof Date;
 }
-
 function isRegExp(x) {
   return x instanceof RegExp;
 }
-
 function isObject(x) {
-  return !!(x && _typeof(x) === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
+  return !!(x && (0, _typeof2["default"])(x) === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
 }
-
 function isNull(x) {
   return x === null;
 }
-
 function isUndefined(x) {
   return x === undefined;
 }
-
 function isAccessorNode(x) {
   return x && x.isAccessorNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isArrayNode(x) {
   return x && x.isArrayNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isAssignmentNode(x) {
   return x && x.isAssignmentNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isBlockNode(x) {
   return x && x.isBlockNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isConditionalNode(x) {
   return x && x.isConditionalNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isConstantNode(x) {
   return x && x.isConstantNode === true && x.constructor.prototype.isNode === true || false;
 }
 
+/* Very specialized: returns true for those nodes which in the numerator of
+   a fraction means that the division in that fraction has precedence over implicit
+   multiplication, e.g. -2/3 x parses as (-2/3) x and 3/4 x parses as (3/4) x but
+   6!/8 x parses as 6! / (8x). It is located here because it is shared between
+   parse.js and OperatorNode.js (for parsing and printing, respectively).
+
+   This should *not* be exported from mathjs, unlike most of the tests here.
+   Its name does not start with 'is' to prevent utils/snapshot.js from thinking
+   it should be exported.
+*/
+function rule2Node(node) {
+  return isConstantNode(node) || isOperatorNode(node) && node.args.length === 1 && isConstantNode(node.args[0]) && '-+~'.includes(node.op);
+}
 function isFunctionAssignmentNode(x) {
   return x && x.isFunctionAssignmentNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isFunctionNode(x) {
   return x && x.isFunctionNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isIndexNode(x) {
   return x && x.isIndexNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isNode(x) {
   return x && x.isNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isObjectNode(x) {
   return x && x.isObjectNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isOperatorNode(x) {
   return x && x.isOperatorNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isParenthesisNode(x) {
   return x && x.isParenthesisNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isRangeNode(x) {
   return x && x.isRangeNode === true && x.constructor.prototype.isNode === true || false;
 }
-
+function isRelationalNode(x) {
+  return x && x.isRelationalNode === true && x.constructor.prototype.isNode === true || false;
+}
 function isSymbolNode(x) {
   return x && x.isSymbolNode === true && x.constructor.prototype.isNode === true || false;
 }
-
 function isChain(x) {
   return x && x.constructor.prototype.isChain === true || false;
 }
-
 function typeOf(x) {
-  var t = _typeof(x);
-
+  var t = (0, _typeof2["default"])(x);
   if (t === 'object') {
-    // JavaScript types
     if (x === null) return 'null';
-    if (Array.isArray(x)) return 'Array';
-    if (x instanceof Date) return 'Date';
-    if (x instanceof RegExp) return 'RegExp'; // math.js types
-
-    if (isBigNumber(x)) return 'BigNumber';
-    if (isComplex(x)) return 'Complex';
-    if (isFraction(x)) return 'Fraction';
-    if (isMatrix(x)) return 'Matrix';
-    if (isUnit(x)) return 'Unit';
-    if (isIndex(x)) return 'Index';
-    if (isRange(x)) return 'Range';
-    if (isResultSet(x)) return 'ResultSet';
-    if (isNode(x)) return x.type;
-    if (isChain(x)) return 'Chain';
-    if (isHelp(x)) return 'Help';
-    return 'Object';
+    if (isBigNumber(x)) return 'BigNumber'; // Special: weird mashup with Decimal
+    if (x.constructor && x.constructor.name) return x.constructor.name;
+    return 'Object'; // just in case
   }
-
-  if (t === 'function') return 'Function';
-  return t; // can be 'string', 'number', 'boolean', ...
+  return t; // can be 'string', 'number', 'boolean', 'function', 'bigint', ...
 }

package/lib/cjs/utils/latex.js

@@ -1,20 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.defaultTemplate = void 0;
 exports.escapeLatex = escapeLatex;
+exports.latexSymbols = exports.latexOperators = exports.latexFunctions = void 0;
 exports.toSymbol = toSymbol;
-exports.defaultTemplate = exports.latexFunctions = exports.latexOperators = exports.latexSymbols = void 0;
-
 var _escapeLatex = _interopRequireDefault(require("escape-latex"));
-
 var _object = require("./object.js");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
 /* eslint no-template-curly-in-string: "off" */
-var latexSymbols = {
+
+var latexSymbols = exports.latexSymbols = {
   // GREEK LETTERS
   Alpha: 'A',
   alpha: '\\alpha',
@@ -85,8 +83,7 @@ var latexSymbols = {
   lim: '\\lim',
   undefined: '\\mathbf{?}'
 };
-exports.latexSymbols = latexSymbols;
-var latexOperators = {
+var latexOperators = exports.latexOperators = {
   transpose: '^\\top',
   ctranspose: '^H',
   factorial: '!',
@@ -125,8 +122,7 @@ var latexOperators = {
   xor: '\\veebar',
   or: '\\vee'
 };
-exports.latexOperators = latexOperators;
-var latexFunctions = {
+var latexFunctions = exports.latexFunctions = {
   // arithmetic
   abs: {
     1: '\\left|${args[0]}\\right|'
@@ -188,7 +184,6 @@ var latexFunctions = {
   norm: {
     1: '\\left\\|${args[0]}\\right\\|',
     2: undefined // use default template
-
   },
   nthRoot: {
     2: '\\sqrt[${args[1]}]{${args[0]}}'
@@ -202,7 +197,6 @@ var latexFunctions = {
   round: {
     1: '\\left\\lfloor${args[0]}\\right\\rceil',
     2: undefined // use default template
-
   },
   sign: {
     1: '\\mathrm{${name}}\\left(${args[0]}\\right)'
@@ -299,6 +293,9 @@ var latexFunctions = {
   inv: {
     1: '\\left(${args[0]}\\right)^{-1}'
   },
+  pinv: {
+    1: '\\left(${args[0]}\\right)^{+}'
+  },
   sqrtm: {
     1: "{${args[0]}}".concat(latexOperators.pow, "{\\frac{1}{2}}")
   },
@@ -321,6 +318,9 @@ var latexFunctions = {
   gamma: {
     1: '\\Gamma\\left(${args[0]}\\right)'
   },
+  lgamma: {
+    1: '\\ln\\Gamma\\left(${args[0]}\\right)'
+  },
   // relational
   equal: {
     2: "\\left(${args[0]}".concat(latexOperators.equal, "${args[1]}\\right)")
@@ -466,35 +466,28 @@ var latexFunctions = {
     2: '\\left(\\left(${args[0]}\\right)${args[1]}\\right)'
   }
 };
-exports.latexFunctions = latexFunctions;
-var defaultTemplate = '\\mathrm{${name}}\\left(${args}\\right)';
-exports.defaultTemplate = defaultTemplate;
+var defaultTemplate = exports.defaultTemplate = '\\mathrm{${name}}\\left(${args}\\right)';
 var latexUnits = {
   deg: '^\\circ'
 };
-
 function escapeLatex(string) {
   return (0, _escapeLatex["default"])(string, {
     preserveFormatting: true
   });
-} // @param {string} name
-// @param {boolean} isUnit
-
+}
 
+// @param {string} name
+// @param {boolean} isUnit
 function toSymbol(name, isUnit) {
   isUnit = typeof isUnit === 'undefined' ? false : isUnit;
-
   if (isUnit) {
     if ((0, _object.hasOwnProperty)(latexUnits, name)) {
       return latexUnits[name];
     }
-
     return '\\mathrm{' + escapeLatex(name) + '}';
   }
-
   if ((0, _object.hasOwnProperty)(latexSymbols, name)) {
     return latexSymbols[name];
   }
-
   return escapeLatex(name);
 }

package/lib/cjs/utils/log.js

@@ -4,27 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.warnOnce = void 0;
-
 /**
  * Log a console.warn message only once
  */
-var warnOnce = function () {
+var warnOnce = exports.warnOnce = function () {
   var messages = {};
   return function warnOnce() {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     var message = args.join(', ');
-
     if (!messages[message]) {
       var _console;
-
       messages[message] = true;
-
       (_console = console).warn.apply(_console, ['Warning:'].concat(args));
     }
   };
-}();
-
-exports.warnOnce = warnOnce;
+}();

package/lib/cjs/utils/lruQueue.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lruQueue = lruQueue;
+// (c) 2018, Mariusz Nowak
+// SPDX-License-Identifier: ISC
+// Derived from https://github.com/medikoo/lru-queue
+function lruQueue(limit) {
+  var size = 0;
+  var base = 1;
+  var queue = Object.create(null);
+  var map = Object.create(null);
+  var index = 0;
+  var del = function del(id) {
+    var oldIndex = map[id];
+    if (!oldIndex) return;
+    delete queue[oldIndex];
+    delete map[id];
+    --size;
+    if (base !== oldIndex) return;
+    if (!size) {
+      index = 0;
+      base = 1;
+      return;
+    }
+    while (!Object.prototype.hasOwnProperty.call(queue, ++base)) {/* empty */}
+  };
+  limit = Math.abs(limit);
+  return {
+    hit: function hit(id) {
+      var oldIndex = map[id];
+      var nuIndex = ++index;
+      queue[nuIndex] = id;
+      map[id] = nuIndex;
+      if (!oldIndex) {
+        ++size;
+        if (size <= limit) return undefined;
+        id = queue[base];
+        del(id);
+        return id;
+      }
+      delete queue[oldIndex];
+      if (base !== oldIndex) return undefined;
+      while (!Object.prototype.hasOwnProperty.call(queue, ++base)) {/* empty */}
+      return undefined;
+    },
+    "delete": del,
+    clear: function clear() {
+      size = index = 0;
+      base = 1;
+      queue = Object.create(null);
+      map = Object.create(null);
+    }
+  };
+}

package/lib/cjs/utils/map.js

@@ -0,0 +1,166 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ObjectWrappingMap = void 0;
+exports.assign = assign;
+exports.createEmptyMap = createEmptyMap;
+exports.createMap = createMap;
+exports.isMap = isMap;
+exports.toObject = toObject;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _customs = require("./customs.js");
+var _is = require("./is.js");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * A map facade on a bare object.
+ *
+ * The small number of methods needed to implement a scope,
+ * forwarding on to the SafeProperty functions. Over time, the codebase
+ * will stop using this method, as all objects will be Maps, rather than
+ * more security prone objects.
+ */
+var ObjectWrappingMap = exports.ObjectWrappingMap = /*#__PURE__*/function () {
+  function ObjectWrappingMap(object) {
+    (0, _classCallCheck2["default"])(this, ObjectWrappingMap);
+    this.wrappedObject = object;
+  }
+  (0, _createClass2["default"])(ObjectWrappingMap, [{
+    key: "keys",
+    value: function keys() {
+      return Object.keys(this.wrappedObject);
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return (0, _customs.getSafeProperty)(this.wrappedObject, key);
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      (0, _customs.setSafeProperty)(this.wrappedObject, key, value);
+      return this;
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      return (0, _customs.hasSafeProperty)(this.wrappedObject, key);
+    }
+  }]);
+  return ObjectWrappingMap;
+}();
+/**
+ * Creates an empty map, or whatever your platform's polyfill is.
+ *
+ * @returns an empty Map or Map like object.
+ */
+function createEmptyMap() {
+  return new Map();
+}
+
+/**
+ * Creates a Map from the given object.
+ *
+ * @param { Map | { [key: string]: unknown } | undefined } mapOrObject
+ * @returns
+ */
+function createMap(mapOrObject) {
+  if (!mapOrObject) {
+    return createEmptyMap();
+  }
+  if (isMap(mapOrObject)) {
+    return mapOrObject;
+  }
+  if ((0, _is.isObject)(mapOrObject)) {
+    return new ObjectWrappingMap(mapOrObject);
+  }
+  throw new Error('createMap can create maps from objects or Maps');
+}
+
+/**
+ * Unwraps a map into an object.
+ *
+ * @param {Map} map
+ * @returns { [key: string]: unknown }
+ */
+function toObject(map) {
+  if (map instanceof ObjectWrappingMap) {
+    return map.wrappedObject;
+  }
+  var object = {};
+  var _iterator = _createForOfIteratorHelper(map.keys()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      var value = map.get(key);
+      (0, _customs.setSafeProperty)(object, key, value);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return object;
+}
+
+/**
+ * Returns `true` if the passed object appears to be a Map (i.e. duck typing).
+ *
+ * Methods looked for are `get`, `set`, `keys` and `has`.
+ *
+ * @param {Map | object} object
+ * @returns
+ */
+function isMap(object) {
+  // We can use the fast instanceof, or a slower duck typing check.
+  // The duck typing method needs to cover enough methods to not be confused with DenseMatrix.
+  if (!object) {
+    return false;
+  }
+  return object instanceof Map || object instanceof ObjectWrappingMap || typeof object.set === 'function' && typeof object.get === 'function' && typeof object.keys === 'function' && typeof object.has === 'function';
+}
+
+/**
+ * Copies the contents of key-value pairs from each `objects` in to `map`.
+ *
+ * Object is `objects` can be a `Map` or object.
+ *
+ * This is the `Map` analog to `Object.assign`.
+ */
+function assign(map) {
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    objects[_key - 1] = arguments[_key];
+  }
+  for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
+    var args = _objects[_i];
+    if (!args) {
+      continue;
+    }
+    if (isMap(args)) {
+      var _iterator2 = _createForOfIteratorHelper(args.keys()),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var key = _step2.value;
+          map.set(key, args.get(key));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    } else if ((0, _is.isObject)(args)) {
+      for (var _i2 = 0, _Object$keys = Object.keys(args); _i2 < _Object$keys.length; _i2++) {
+        var _key2 = _Object$keys[_i2];
+        map.set(_key2, args[_key2]);
+      }
+    }
+  }
+  return map;
+}