mathjs 11.2.1 → 11.3.0

package/lib/cjs/utils/bignumber/nearlyEqual.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.nearlyEqual = nearlyEqual;
-
 /**
  * Compares two BigNumbers.
  * @param {BigNumber} x       First value to compare
@@ -18,23 +17,22 @@ function nearlyEqual(x, y, epsilon) {
   // if epsilon is null or undefined, test whether x and y are exactly equal
   if (epsilon === null || epsilon === undefined) {
     return x.eq(y);
-  } // use "==" operator, handles infinities
-
+  }
 
+  // use "==" operator, handles infinities
   if (x.eq(y)) {
     return true;
-  } // NaN
-
+  }
 
+  // NaN
   if (x.isNaN() || y.isNaN()) {
     return false;
-  } // at this point x and y should be finite
-
+  }
 
+  // at this point x and y should be finite
   if (x.isFinite() && y.isFinite()) {
     // check numbers are very close, needed when comparing numbers near zero
     var diff = x.minus(y).abs();
-
     if (diff.isZero()) {
       return true;
     } else {
@@ -42,8 +40,8 @@ function nearlyEqual(x, y, epsilon) {
       var max = x.constructor.max(x.abs(), y.abs());
       return diff.lte(max.times(epsilon));
     }
-  } // Infinite and Number or negative Infinite and positive Infinite cases
-
+  }
 
+  // Infinite and Number or negative Infinite and positive Infinite cases
   return false;
 }

package/lib/cjs/utils/collection.js

@@ -8,15 +8,10 @@ exports.deepForEach = deepForEach;
 exports.deepMap = deepMap;
 exports.reduce = reduce;
 exports.scatter = scatter;
-
 var _is = require("./is.js");
-
 var _IndexError = require("../error/IndexError.js");
-
 var _array = require("./array.js");
-
 var _switch2 = require("./switch.js");
-
 /**
  * Test whether an array contains collections
  * @param {Array} array
@@ -29,9 +24,9 @@ function containsCollections(array) {
       return true;
     }
   }
-
   return false;
 }
+
 /**
  * Recursively loop over all elements in a given multi dimensional array
  * and invoke the callback on each of the elements.
@@ -39,16 +34,12 @@ function containsCollections(array) {
  * @param {Function} callback     The callback method is invoked with one
  *                                parameter: the current element in the array
  */
-
-
 function deepForEach(array, callback) {
   if ((0, _is.isMatrix)(array)) {
     array = array.valueOf();
   }
-
   for (var i = 0, ii = array.length; i < ii; i++) {
     var value = array[i];
-
     if (Array.isArray(value)) {
       deepForEach(value, callback);
     } else {
@@ -56,6 +47,7 @@ function deepForEach(array, callback) {
     }
   }
 }
+
 /**
  * Execute the callback function element wise for each element in array and any
  * nested array
@@ -68,8 +60,6 @@ function deepForEach(array, callback) {
  *
  * @return {Array | Matrix} res
  */
-
-
 function deepMap(array, callback, skipZeros) {
   if (array && typeof array.map === 'function') {
     // TODO: replace array.map with a for loop to improve performance
@@ -80,6 +70,7 @@ function deepMap(array, callback, skipZeros) {
     return callback(array);
   }
 }
+
 /**
  * Reduce a given matrix or array to a new matrix or
  * array with one less dimension, applying the given
@@ -89,22 +80,19 @@ function deepMap(array, callback, skipZeros) {
  * @param {Function} callback
  * @return {Array | Matrix} res
  */
-
-
 function reduce(mat, dim, callback) {
   var size = Array.isArray(mat) ? (0, _array.arraySize)(mat) : mat.size();
-
   if (dim < 0 || dim >= size.length) {
     // TODO: would be more clear when throwing a DimensionError here
     throw new _IndexError.IndexError(dim, size.length);
   }
-
   if ((0, _is.isMatrix)(mat)) {
     return mat.create(_reduce(mat.valueOf(), dim, callback));
   } else {
     return _reduce(mat, dim, callback);
   }
 }
+
 /**
  * Recursively reduce a matrix
  * @param {Array} mat
@@ -113,66 +101,59 @@ function reduce(mat, dim, callback) {
  * @returns {Array} ret
  * @private
  */
-
-
 function _reduce(mat, dim, callback) {
   var i, ret, val, tran;
-
   if (dim <= 0) {
     if (!Array.isArray(mat[0])) {
       val = mat[0];
-
       for (i = 1; i < mat.length; i++) {
         val = callback(val, mat[i]);
       }
-
       return val;
     } else {
       tran = (0, _switch2._switch)(mat);
       ret = [];
-
       for (i = 0; i < tran.length; i++) {
         ret[i] = _reduce(tran[i], dim - 1, callback);
       }
-
       return ret;
     }
   } else {
     ret = [];
-
     for (i = 0; i < mat.length; i++) {
       ret[i] = _reduce(mat[i], dim - 1, callback);
     }
-
     return ret;
   }
-} // TODO: document function scatter
-
+}
 
+// TODO: document function scatter
 function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
   // a arrays
   var avalues = a._values;
   var aindex = a._index;
-  var aptr = a._ptr; // vars
+  var aptr = a._ptr;
 
-  var k, k0, k1, i; // check we need to process values (pattern matrix)
+  // vars
+  var k, k0, k1, i;
 
+  // check we need to process values (pattern matrix)
   if (x) {
     // values in j
     for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
       // row
-      i = aindex[k]; // check value exists in current j
-
+      i = aindex[k];
+      // check value exists in current j
       if (w[i] !== mark) {
         // i is new entry in j
-        w[i] = mark; // add i to pattern of C
-
-        cindex.push(i); // x(i) = A, check we need to call function this time
-
+        w[i] = mark;
+        // add i to pattern of C
+        cindex.push(i);
+        // x(i) = A, check we need to call function this time
         if (update) {
           // copy value to workspace calling callback function
-          x[i] = inverse ? f(avalues[k], value) : f(value, avalues[k]); // function was called on current row
-
+          x[i] = inverse ? f(avalues[k], value) : f(value, avalues[k]);
+          // function was called on current row
           u[i] = mark;
         } else {
           // copy value to workspace
@@ -180,8 +161,8 @@ function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
         }
       } else {
         // i exists in C already
-        x[i] = inverse ? f(avalues[k], x[i]) : f(x[i], avalues[k]); // function was called on current row
-
+        x[i] = inverse ? f(avalues[k], x[i]) : f(x[i], avalues[k]);
+        // function was called on current row
         u[i] = mark;
       }
     }
@@ -189,12 +170,12 @@ function scatter(a, j, w, x, u, mark, cindex, f, inverse, update, value) {
     // values in j
     for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
       // row
-      i = aindex[k]; // check value exists in current j
-
+      i = aindex[k];
+      // check value exists in current j
       if (w[i] !== mark) {
         // i is new entry in j
-        w[i] = mark; // add i to pattern of C
-
+        w[i] = mark;
+        // add i to pattern of C
         cindex.push(i);
       } else {
         // indicate function was called on current row

package/lib/cjs/utils/complex.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.complexEquals = complexEquals;
-
 var _number = require("./number.js");
-
 /**
  * Test whether two complex values are equal provided a given epsilon.
  * Does not use or change the global Complex.EPSILON setting

package/lib/cjs/utils/customs.js

@@ -1,7 +1,6 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -13,11 +12,8 @@ exports.isSafeMethod = isSafeMethod;
 exports.isSafeProperty = isSafeProperty;
 exports.setSafeProperty = setSafeProperty;
 exports.validateSafeMethod = validateSafeMethod;
-
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
 var _object = require("./object.js");
-
 /**
  * Get a property of a plain object
  * Throws an error in case the object is not a plain object or the
@@ -31,13 +27,12 @@ function getSafeProperty(object, prop) {
   if (isPlainObject(object) && isSafeProperty(object, prop)) {
     return object[prop];
   }
-
   if (typeof object[prop] === 'function' && isSafeMethod(object, prop)) {
     throw new Error('Cannot access method "' + prop + '" as a property');
   }
-
   throw new Error('No access to property "' + prop + '"');
 }
+
 /**
  * Set a property on a plain object.
  * Throws an error in case the object is not a plain object or the
@@ -48,66 +43,57 @@ function getSafeProperty(object, prop) {
  * @return {*} Returns the value
  */
 // TODO: merge this function into access.js?
-
-
 function setSafeProperty(object, prop, value) {
   // only allow setting safe properties of a plain object
   if (isPlainObject(object) && isSafeProperty(object, prop)) {
     object[prop] = value;
     return value;
   }
-
   throw new Error('No access to property "' + prop + '"');
 }
-
 function getSafeProperties(object) {
   return Object.keys(object).filter(function (prop) {
     return (0, _object.hasOwnProperty)(object, prop);
   });
 }
-
 function hasSafeProperty(object, prop) {
   return prop in object;
 }
+
 /**
  * Test whether a property is safe to use for an object.
  * For example .toString and .constructor are not safe
  * @param {string} prop
  * @return {boolean} Returns true when safe
  */
-
-
 function isSafeProperty(object, prop) {
   if (!object || (0, _typeof2["default"])(object) !== 'object') {
     return false;
-  } // SAFE: whitelisted
+  }
+  // SAFE: whitelisted
   // e.g length
-
-
   if ((0, _object.hasOwnProperty)(safeNativeProperties, prop)) {
     return true;
-  } // UNSAFE: inherited from Object prototype
+  }
+  // UNSAFE: inherited from Object prototype
   // e.g constructor
-
-
   if (prop in Object.prototype) {
     // 'in' is used instead of hasOwnProperty for nodejs v0.10
     // which is inconsistent on root prototypes. It is safe
     // here because Object.prototype is a root object
     return false;
-  } // UNSAFE: inherited from Function prototype
+  }
+  // UNSAFE: inherited from Function prototype
   // e.g call, apply
-
-
   if (prop in Function.prototype) {
     // 'in' is used instead of hasOwnProperty for nodejs v0.10
     // which is inconsistent on root prototypes. It is safe
     // here because Function.prototype is a root object
     return false;
   }
-
   return true;
 }
+
 /**
  * Validate whether a method is safe.
  * Throws an error when that's not the case.
@@ -115,13 +101,12 @@ function isSafeProperty(object, prop) {
  * @param {string} method
  */
 // TODO: merge this function into assign.js?
-
-
 function validateSafeMethod(object, method) {
   if (!isSafeMethod(object, method)) {
     throw new Error('No access to method "' + method + '"');
   }
 }
+
 /**
  * Check whether a method is safe.
  * Throws an error when that's not the case (for example for `constructor`).
@@ -129,51 +114,42 @@ function validateSafeMethod(object, method) {
  * @param {string} method
  * @return {boolean} Returns true when safe, false otherwise
  */
-
-
 function isSafeMethod(object, method) {
   if (object === null || object === undefined || typeof object[method] !== 'function') {
     return false;
-  } // UNSAFE: ghosted
+  }
+  // UNSAFE: ghosted
   // e.g overridden toString
   // Note that IE10 doesn't support __proto__ and we can't do this check there.
-
-
   if ((0, _object.hasOwnProperty)(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
     return false;
-  } // SAFE: whitelisted
+  }
+  // SAFE: whitelisted
   // e.g toString
-
-
   if ((0, _object.hasOwnProperty)(safeNativeMethods, method)) {
     return true;
-  } // UNSAFE: inherited from Object prototype
+  }
+  // UNSAFE: inherited from Object prototype
   // e.g constructor
-
-
   if (method in Object.prototype) {
     // 'in' is used instead of hasOwnProperty for nodejs v0.10
     // which is inconsistent on root prototypes. It is safe
     // here because Object.prototype is a root object
     return false;
-  } // UNSAFE: inherited from Function prototype
+  }
+  // UNSAFE: inherited from Function prototype
   // e.g call, apply
-
-
   if (method in Function.prototype) {
     // 'in' is used instead of hasOwnProperty for nodejs v0.10
     // which is inconsistent on root prototypes. It is safe
     // here because Function.prototype is a root object
     return false;
   }
-
   return true;
 }
-
 function isPlainObject(object) {
   return (0, _typeof2["default"])(object) === 'object' && object && object.constructor === Object;
 }
-
 var safeNativeProperties = {
   length: true,
   name: true

package/lib/cjs/utils/emitter.js

@@ -1,14 +1,11 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.mixin = mixin;
-
 var _tinyEmitter = _interopRequireDefault(require("tiny-emitter"));
-
 /**
  * Extend given object with emitter functions `on`, `off`, `once`, `emit`
  * @param {Object} obj
@@ -16,8 +13,9 @@ var _tinyEmitter = _interopRequireDefault(require("tiny-emitter"));
  */
 function mixin(obj) {
   // create event emitter
-  var emitter = new _tinyEmitter["default"](); // bind methods to obj (we don't want to expose the emitter.e Array...)
+  var emitter = new _tinyEmitter["default"]();
 
+  // bind methods to obj (we don't want to expose the emitter.e Array...)
   obj.on = emitter.on.bind(emitter);
   obj.off = emitter.off.bind(emitter);
   obj.once = emitter.once.bind(emitter);

package/lib/cjs/utils/factory.js

@@ -10,11 +10,8 @@ exports.isFactory = isFactory;
 exports.isOptionalDependency = isOptionalDependency;
 exports.sortFactories = sortFactories;
 exports.stripOptionalNotation = stripOptionalNotation;
-
 var _array = require("./array.js");
-
 var _object = require("./object.js");
-
 /**
  * Create a factory function, which can be used to inject dependencies.
  *
@@ -48,70 +45,60 @@ function factory(name, dependencies, create, meta) {
     assertDependencies(name, dependencies, scope);
     return create(deps);
   }
-
   assertAndCreate.isFactory = true;
   assertAndCreate.fn = name;
   assertAndCreate.dependencies = dependencies.slice().sort();
-
   if (meta) {
     assertAndCreate.meta = meta;
   }
-
   return assertAndCreate;
 }
+
 /**
  * Sort all factories such that when loading in order, the dependencies are resolved.
  *
  * @param {Array} factories
  * @returns {Array} Returns a new array with the sorted factories.
  */
-
-
 function sortFactories(factories) {
   var factoriesByName = {};
   factories.forEach(function (factory) {
     factoriesByName[factory.fn] = factory;
   });
-
   function containsDependency(factory, dependency) {
     // TODO: detect circular references
     if (isFactory(factory)) {
       if ((0, _array.contains)(factory.dependencies, dependency.fn || dependency.name)) {
         return true;
       }
-
       if (factory.dependencies.some(function (d) {
         return containsDependency(factoriesByName[d], dependency);
       })) {
         return true;
       }
     }
-
     return false;
   }
-
   var sorted = [];
-
   function addFactory(factory) {
     var index = 0;
-
     while (index < sorted.length && !containsDependency(sorted[index], factory)) {
       index++;
     }
-
     sorted.splice(index, 0, factory);
-  } // sort regular factory functions
-
+  }
 
-  factories.filter(isFactory).forEach(addFactory); // sort legacy factory functions AFTER the regular factory functions
+  // sort regular factory functions
+  factories.filter(isFactory).forEach(addFactory);
 
+  // sort legacy factory functions AFTER the regular factory functions
   factories.filter(function (factory) {
     return !isFactory(factory);
   }).forEach(addFactory);
   return sorted;
-} // TODO: comment or cleanup if unused in the end
-
+}
 
+// TODO: comment or cleanup if unused in the end
 function create(factories) {
   var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   sortFactories(factories).forEach(function (factory) {
@@ -119,17 +106,17 @@ function create(factories) {
   });
   return scope;
 }
+
 /**
  * Test whether an object is a factory. This is the case when it has
  * properties name, dependencies, and a function create.
  * @param {*} obj
  * @returns {boolean}
  */
-
-
 function isFactory(obj) {
   return typeof obj === 'function' && typeof obj.fn === 'string' && Array.isArray(obj.dependencies);
 }
+
 /**
  * Assert that all dependencies of a list with dependencies are available in the provided scope.
  *
@@ -139,8 +126,6 @@ function isFactory(obj) {
  * @param {string[]} dependencies
  * @param {Object} scope
  */
-
-
 function assertDependencies(name, dependencies, scope) {
   var allDefined = dependencies.filter(function (dependency) {
     return !isOptionalDependency(dependency);
@@ -148,22 +133,20 @@ function assertDependencies(name, dependencies, scope) {
   .every(function (dependency) {
     return scope[dependency] !== undefined;
   });
-
   if (!allDefined) {
     var missingDependencies = dependencies.filter(function (dependency) {
       return scope[dependency] === undefined;
-    }); // TODO: create a custom error class for this, a MathjsError or something like that
+    });
 
+    // TODO: create a custom error class for this, a MathjsError or something like that
     throw new Error("Cannot create function \"".concat(name, "\", ") + "some dependencies are missing: ".concat(missingDependencies.map(function (d) {
       return "\"".concat(d, "\"");
     }).join(', '), "."));
   }
 }
-
 function isOptionalDependency(dependency) {
   return dependency && dependency[0] === '?';
 }
-
 function stripOptionalNotation(dependency) {
   return dependency && dependency[0] === '?' ? dependency.slice(1) : dependency;
 }