mathjs 8.1.0 → 12.2.1

package/lib/esm/utils/function.js

@@ -1,5 +1,7 @@
 // function utils
 
+import { lruQueue } from './lruQueue.js';
+
 /**
  * Memoize a given function by caching the computed result.
  * The cache of a memoized function can be cleared by deleting the `cache`
@@ -7,31 +9,44 @@
  *
  * @param {function} fn                     The function to be memoized.
  *                                          Must be a pure function.
- * @param {function(args: Array)} [hasher]  A custom hash builder.
- *                                          Is JSON.stringify by default.
+ * @param {Object} [options]
+ * @param {function(args: Array): string} [options.hasher]
+ *    A custom hash builder. Is JSON.stringify by default.
+ * @param {number | undefined} [options.limit]
+ *    Maximum number of values that may be cached. Undefined indicates
+ *    unlimited (default)
  * @return {function}                       Returns the memoized function
  */
-export function memoize(fn, hasher) {
+export function memoize(fn) {
+  var {
+    hasher,
+    limit
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  limit = limit == null ? Number.POSITIVE_INFINITY : limit;
+  hasher = hasher == null ? JSON.stringify : hasher;
   return function memoize() {
     if (typeof memoize.cache !== 'object') {
-      memoize.cache = {};
+      memoize.cache = {
+        values: new Map(),
+        lru: lruQueue(limit || Number.POSITIVE_INFINITY)
+      };
     }
-
     var args = [];
-
     for (var i = 0; i < arguments.length; i++) {
       args[i] = arguments[i];
     }
-
-    var hash = hasher ? hasher(args) : JSON.stringify(args);
-
-    if (!(hash in memoize.cache)) {
-      memoize.cache[hash] = fn.apply(fn, args);
+    var hash = hasher(args);
+    if (memoize.cache.values.has(hash)) {
+      memoize.cache.lru.hit(hash);
+      return memoize.cache.values.get(hash);
     }
-
-    return memoize.cache[hash];
+    var newVal = fn.apply(fn, args);
+    memoize.cache.values.set(hash, newVal);
+    memoize.cache.values.delete(memoize.cache.lru.hit(hash));
+    return newVal;
   };
 }
+
 /**
  * Memoize a given function by caching all results and the arguments,
  * and comparing against the arguments of previous results before
@@ -46,24 +61,19 @@ export function memoize(fn, hasher) {
  * @param {function(a: *, b: *) : boolean} isEqual
  * @returns {function}
  */
-
 export function memoizeCompare(fn, isEqual) {
   var memoize = function memoize() {
     var args = [];
-
     for (var i = 0; i < arguments.length; i++) {
       args[i] = arguments[i];
     }
-
     for (var c = 0; c < memoize.cache.length; c++) {
       var cached = memoize.cache[c];
-
       if (isEqual(args, cached.args)) {
         // TODO: move this cache entry to the top so recently used entries move up?
         return cached.res;
       }
     }
-
     var res = fn.apply(fn, args);
     memoize.cache.unshift({
       args,
@@ -71,17 +81,16 @@ export function memoizeCompare(fn, isEqual) {
     });
     return res;
   };
-
   memoize.cache = [];
   return memoize;
 }
+
 /**
  * Find the maximum number of arguments expected by a typed function.
  * @param {function} fn   A typed function
  * @return {number} Returns the maximum number of expected arguments.
  *                  Returns -1 when no signatures where found on the function.
  */
-
 export function maxArgumentCount(fn) {
   return Object.keys(fn.signatures || {}).reduce(function (args, signature) {
     var count = (signature.match(/,/g) || []).length + 1;

package/lib/esm/utils/is.js

@@ -11,11 +11,21 @@
 // - 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.
+
 export function isNumber(x) {
   return typeof x === 'number';
 }
 export function isBigNumber(x) {
-  return x && x.constructor.prototype.isBigNumber === true || false;
+  if (!x || typeof x !== 'object' || typeof x.constructor !== 'function') {
+    return false;
+  }
+  if (x.isBigNumber === true && typeof 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;
 }
 export function isComplex(x) {
   return x && typeof x === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
@@ -33,12 +43,12 @@ export var isArray = Array.isArray;
 export 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
  */
-
 export function isCollection(x) {
   return Array.isArray(x) || isMatrix(x);
 }
@@ -99,6 +109,20 @@ export function isConditionalNode(x) {
 export 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.
+*/
+export function rule2Node(node) {
+  return isConstantNode(node) || isOperatorNode(node) && node.args.length === 1 && isConstantNode(node.args[0]) && '-+~'.includes(node.op);
+}
 export function isFunctionAssignmentNode(x) {
   return x && x.isFunctionAssignmentNode === true && x.constructor.prototype.isNode === true || false;
 }
@@ -123,6 +147,9 @@ export function isParenthesisNode(x) {
 export function isRangeNode(x) {
   return x && x.isRangeNode === true && x.constructor.prototype.isNode === true || false;
 }
+export function isRelationalNode(x) {
+  return x && x.isRelationalNode === true && x.constructor.prototype.isNode === true || false;
+}
 export function isSymbolNode(x) {
   return x && x.isSymbolNode === true && x.constructor.prototype.isNode === true || false;
 }
@@ -131,28 +158,11 @@ export function isChain(x) {
 }
 export function typeOf(x) {
   var t = typeof 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/esm/utils/latex.js

@@ -1,4 +1,5 @@
 /* eslint no-template-curly-in-string: "off" */
+
 import escapeLatexLib from 'escape-latex';
 import { hasOwnProperty } from './object.js';
 export var latexSymbols = {
@@ -173,7 +174,6 @@ export var latexFunctions = {
   norm: {
     1: '\\left\\|${args[0]}\\right\\|',
     2: undefined // use default template
-
   },
   nthRoot: {
     2: '\\sqrt[${args[1]}]{${args[0]}}'
@@ -187,7 +187,6 @@ export var latexFunctions = {
   round: {
     1: '\\left\\lfloor${args[0]}\\right\\rceil',
     2: undefined // use default template
-
   },
   sign: {
     1: '\\mathrm{${name}}\\left(${args[0]}\\right)'
@@ -284,6 +283,9 @@ export 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}}")
   },
@@ -306,6 +308,9 @@ export 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)")
@@ -459,23 +464,20 @@ export function escapeLatex(string) {
   return escapeLatexLib(string, {
     preserveFormatting: true
   });
-} // @param {string} name
-// @param {boolean} isUnit
+}
 
+// @param {string} name
+// @param {boolean} isUnit
 export function toSymbol(name, isUnit) {
   isUnit = typeof isUnit === 'undefined' ? false : isUnit;
-
   if (isUnit) {
     if (hasOwnProperty(latexUnits, name)) {
       return latexUnits[name];
     }
-
     return '\\mathrm{' + escapeLatex(name) + '}';
   }
-
   if (hasOwnProperty(latexSymbols, name)) {
     return latexSymbols[name];
   }
-
   return escapeLatex(name);
 }

package/lib/esm/utils/log.js

@@ -7,9 +7,7 @@ export var 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]) {
       messages[message] = true;
       console.warn('Warning:', ...args);

package/lib/esm/utils/lruQueue.js

@@ -0,0 +1,51 @@
+// (c) 2018, Mariusz Nowak
+// SPDX-License-Identifier: ISC
+// Derived from https://github.com/medikoo/lru-queue
+export 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/esm/utils/map.js

@@ -0,0 +1,120 @@
+import { setSafeProperty, hasSafeProperty, getSafeProperty } from './customs.js';
+import { isObject } from './is.js';
+
+/**
+ * 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.
+ */
+export class ObjectWrappingMap {
+  constructor(object) {
+    this.wrappedObject = object;
+  }
+  keys() {
+    return Object.keys(this.wrappedObject);
+  }
+  get(key) {
+    return getSafeProperty(this.wrappedObject, key);
+  }
+  set(key, value) {
+    setSafeProperty(this.wrappedObject, key, value);
+    return this;
+  }
+  has(key) {
+    return hasSafeProperty(this.wrappedObject, key);
+  }
+}
+
+/**
+ * Creates an empty map, or whatever your platform's polyfill is.
+ *
+ * @returns an empty Map or Map like object.
+ */
+export function createEmptyMap() {
+  return new Map();
+}
+
+/**
+ * Creates a Map from the given object.
+ *
+ * @param { Map | { [key: string]: unknown } | undefined } mapOrObject
+ * @returns
+ */
+export function createMap(mapOrObject) {
+  if (!mapOrObject) {
+    return createEmptyMap();
+  }
+  if (isMap(mapOrObject)) {
+    return mapOrObject;
+  }
+  if (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 }
+ */
+export function toObject(map) {
+  if (map instanceof ObjectWrappingMap) {
+    return map.wrappedObject;
+  }
+  var object = {};
+  for (var key of map.keys()) {
+    var value = map.get(key);
+    setSafeProperty(object, key, value);
+  }
+  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
+ */
+export 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`.
+ */
+export 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 args of objects) {
+    if (!args) {
+      continue;
+    }
+    if (isMap(args)) {
+      for (var key of args.keys()) {
+        map.set(key, args.get(key));
+      }
+    } else if (isObject(args)) {
+      for (var _key2 of Object.keys(args)) {
+        map.set(_key2, args[_key2]);
+      }
+    }
+  }
+  return map;
+}