mathjs 8.1.0 → 12.2.1

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

@@ -11,23 +11,22 @@ export 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 {
@@ -35,8 +34,8 @@ export 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/esm/utils/collection.js

@@ -1,22 +1,23 @@
 import { isCollection, isMatrix } from './is.js';
 import { IndexError } from '../error/IndexError.js';
 import { arraySize } from './array.js';
+import { _switch } from './switch.js';
+
 /**
  * Test whether an array contains collections
  * @param {Array} array
  * @returns {boolean} Returns true when the array contains one or multiple
  *                    collections (Arrays or Matrices). Returns false otherwise.
  */
-
 export function containsCollections(array) {
   for (var i = 0; i < array.length; i++) {
     if (isCollection(array[i])) {
       return true;
     }
   }
-
   return false;
 }
+
 /**
  * Recursively loop over all elements in a given multi dimensional array
  * and invoke the callback on each of the elements.
@@ -24,15 +25,12 @@ export function containsCollections(array) {
  * @param {Function} callback     The callback method is invoked with one
  *                                parameter: the current element in the array
  */
-
 export function deepForEach(array, callback) {
   if (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 {
@@ -40,6 +38,7 @@ export function deepForEach(array, callback) {
     }
   }
 }
+
 /**
  * Execute the callback function element wise for each element in array and any
  * nested array
@@ -52,7 +51,6 @@ export function deepForEach(array, callback) {
  *
  * @return {Array | Matrix} res
  */
-
 export function deepMap(array, callback, skipZeros) {
   if (array && typeof array.map === 'function') {
     // TODO: replace array.map with a for loop to improve performance
@@ -63,6 +61,7 @@ export 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
@@ -72,21 +71,19 @@ export function deepMap(array, callback, skipZeros) {
  * @param {Function} callback
  * @return {Array | Matrix} res
  */
-
 export function reduce(mat, dim, callback) {
   var size = Array.isArray(mat) ? arraySize(mat) : mat.size();
-
   if (dim < 0 || dim >= size.length) {
     // TODO: would be more clear when throwing a DimensionError here
     throw new IndexError(dim, size.length);
   }
-
   if (isMatrix(mat)) {
     return mat.create(_reduce(mat.valueOf(), dim, callback));
   } else {
     return _reduce(mat, dim, callback);
   }
 }
+
 /**
  * Recursively reduce a matrix
  * @param {Array} mat
@@ -95,91 +92,59 @@ export 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 = _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;
   }
 }
-/**
- * Transpose a matrix
- * @param {Array} mat
- * @returns {Array} ret
- * @private
- */
-
-
-function _switch(mat) {
-  var I = mat.length;
-  var J = mat[0].length;
-  var i, j;
-  var ret = [];
-
-  for (j = 0; j < J; j++) {
-    var tmp = [];
-
-    for (i = 0; i < I; i++) {
-      tmp.push(mat[i][j]);
-    }
-
-    ret.push(tmp);
-  }
-
-  return ret;
-} // TODO: document function scatter
-
 
+// TODO: document function scatter
 export 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
@@ -187,8 +152,8 @@ export 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;
       }
     }
@@ -196,12 +161,12 @@ export 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/esm/utils/complex.js

@@ -1,4 +1,5 @@
 import { nearlyEqual } from './number.js';
+
 /**
  * Test whether two complex values are equal provided a given epsilon.
  * Does not use or change the global Complex.EPSILON setting
@@ -7,7 +8,6 @@ import { nearlyEqual } from './number.js';
  * @param {number} epsilon
  * @returns {boolean}
  */
-
 export function complexEquals(x, y, epsilon) {
   return nearlyEqual(x.re, y.re, epsilon) && nearlyEqual(x.im, y.im, epsilon);
 }

package/lib/esm/utils/customs.js

@@ -1,4 +1,5 @@
 import { hasOwnProperty } from './object.js';
+
 /**
  * Get a property of a plain object
  * Throws an error in case the object is not a plain object or the
@@ -7,19 +8,17 @@ import { hasOwnProperty } from './object.js';
  * @param {string} prop
  * @return {*} Returns the property value when safe
  */
-
 function getSafeProperty(object, prop) {
   // only allow getting safe properties of a plain object
   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
@@ -30,70 +29,69 @@ 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(prop => 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 || typeof object !== 'object') {
     return false;
-  } // SAFE: whitelisted
+  }
+  // SAFE: whitelisted
   // e.g length
-
-
   if (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.
  * @param {Object} object
  * @param {string} method
+ * @return {function} Returns the method when valid
  */
-// TODO: merge this function into assign.js?
-
-
-function validateSafeMethod(object, method) {
+function getSafeMethod(object, method) {
   if (!isSafeMethod(object, method)) {
     throw new Error('No access to method "' + method + '"');
   }
+  return object[method];
 }
+
 /**
  * Check whether a method is safe.
  * Throws an error when that's not the case (for example for `constructor`).
@@ -101,51 +99,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 (hasOwnProperty(object, method) && Object.getPrototypeOf && method in Object.getPrototypeOf(object)) {
     return false;
-  } // SAFE: whitelisted
+  }
+  // SAFE: whitelisted
   // e.g toString
-
-
   if (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 typeof object === 'object' && object && object.constructor === Object;
 }
-
 var safeNativeProperties = {
   length: true,
   name: true
@@ -158,6 +147,8 @@ var safeNativeMethods = {
 export { getSafeProperty };
 export { setSafeProperty };
 export { isSafeProperty };
-export { validateSafeMethod };
+export { hasSafeProperty };
+export { getSafeProperties };
+export { getSafeMethod };
 export { isSafeMethod };
 export { isPlainObject };

package/lib/esm/utils/emitter.js

@@ -1,14 +1,15 @@
 import Emitter from 'tiny-emitter';
+
 /**
  * Extend given object with emitter functions `on`, `off`, `once`, `emit`
  * @param {Object} obj
  * @return {Object} obj
  */
-
 export function mixin(obj) {
   // create event emitter
-  var emitter = new Emitter(); // bind methods to obj (we don't want to expose the emitter.e Array...)
+  var emitter = new Emitter();
 
+  // 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/esm/utils/factory.js

@@ -1,5 +1,6 @@
 import { contains } from './array.js';
 import { pickShallow } from './object.js';
+
 /**
  * Create a factory function, which can be used to inject dependencies.
  *
@@ -24,7 +25,6 @@ import { pickShallow } from './object.js';
  *                                to the created factory function as property `meta`.
  * @returns {function}
  */
-
 export function factory(name, dependencies, create, meta) {
   function assertAndCreate(scope) {
     // we only pass the requested dependencies to the factory function
@@ -34,79 +34,72 @@ export 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.
  */
-
 export function sortFactories(factories) {
   var factoriesByName = {};
   factories.forEach(factory => {
     factoriesByName[factory.fn] = factory;
   });
-
   function containsDependency(factory, dependency) {
     // TODO: detect circular references
     if (isFactory(factory)) {
       if (contains(factory.dependencies, dependency.fn || dependency.name)) {
         return true;
       }
-
       if (factory.dependencies.some(d => 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(factory => !isFactory(factory)).forEach(addFactory);
   return sorted;
-} // TODO: comment or cleanup if unused in the end
+}
 
+// TODO: comment or cleanup if unused in the end
 export function create(factories) {
   var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   sortFactories(factories).forEach(factory => factory(scope));
   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}
  */
-
 export 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.
  *
@@ -116,14 +109,13 @@ export function isFactory(obj) {
  * @param {string[]} dependencies
  * @param {Object} scope
  */
-
 export function assertDependencies(name, dependencies, scope) {
   var allDefined = dependencies.filter(dependency => !isOptionalDependency(dependency)) // filter optionals
   .every(dependency => scope[dependency] !== undefined);
-
   if (!allDefined) {
-    var missingDependencies = dependencies.filter(dependency => scope[dependency] === undefined); // TODO: create a custom error class for this, a MathjsError or something like that
+    var missingDependencies = dependencies.filter(dependency => scope[dependency] === undefined);
 
+    // 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(d => "\"".concat(d, "\"")).join(', '), "."));
   }
 }