@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/utils/bignumber/formatter.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.format = format;
+exports.toEngineering = toEngineering;
+exports.toExponential = toExponential;
+exports.toFixed = toFixed;
+
+var _number = require("../number.js");
+
+/**
+ * Formats a BigNumber in a given base
+ * @param {BigNumber} n
+ * @param {number} base
+ * @param {number} size
+ * @returns {string}
+ */
+function formatBigNumberToBase(n, base, size) {
+  var BigNumberCtor = n.constructor;
+  var big2 = new BigNumberCtor(2);
+  var suffix = '';
+
+  if (size) {
+    if (size < 1) {
+      throw new Error('size must be in greater than 0');
+    }
+
+    if (!(0, _number.isInteger)(size)) {
+      throw new Error('size must be an integer');
+    }
+
+    if (n.greaterThan(big2.pow(size - 1).sub(1)) || n.lessThan(big2.pow(size - 1).mul(-1))) {
+      throw new Error("Value must be in range [-2^".concat(size - 1, ", 2^").concat(size - 1, "-1]"));
+    }
+
+    if (!n.isInteger()) {
+      throw new Error('Value must be an integer');
+    }
+
+    if (n.lessThan(0)) {
+      n = n.add(big2.pow(size));
+    }
+
+    suffix = "i".concat(size);
+  }
+
+  switch (base) {
+    case 2:
+      return "".concat(n.toBinary()).concat(suffix);
+
+    case 8:
+      return "".concat(n.toOctal()).concat(suffix);
+
+    case 16:
+      return "".concat(n.toHexadecimal()).concat(suffix);
+
+    default:
+      throw new Error("Base ".concat(base, " not supported "));
+  }
+}
+/**
+ * Convert a BigNumber to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lower` and `upper` bounds, and uses
+ *                                          exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+ *    format(2.3,    {notation: 'fixed', precision: 4})  // returns '2.3000'
+ *    format(52.8,   {notation: 'exponential'})          // returns '5.28e+1'
+ *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
+ *
+ * @param {BigNumber} value
+ * @param {Object | Function | number} [options]
+ * @return {string} str The formatted value
+ */
+
+
+function format(value, options) {
+  if (typeof options === 'function') {
+    // handle format(value, fn)
+    return options(value);
+  } // handle special cases
+
+
+  if (!value.isFinite()) {
+    return value.isNaN() ? 'NaN' : value.gt(0) ? 'Infinity' : '-Infinity';
+  } // default values for options
+
+
+  var notation = 'auto';
+  var precision;
+  var wordSize;
+
+  if (options !== undefined) {
+    // determine notation from options
+    if (options.notation) {
+      notation = options.notation;
+    } // determine precision from options
+
+
+    if (typeof options === 'number') {
+      precision = options;
+    } else if (options.precision) {
+      precision = options.precision;
+    }
+
+    if (options.wordSize) {
+      wordSize = options.wordSize;
+
+      if (typeof wordSize !== 'number') {
+        throw new Error('Option "wordSize" must be a number');
+      }
+    }
+  } // handle the various notations
+
+
+  switch (notation) {
+    case 'fixed':
+      return toFixed(value, precision);
+
+    case 'exponential':
+      return toExponential(value, precision);
+
+    case 'engineering':
+      return toEngineering(value, precision);
+
+    case 'bin':
+      return formatBigNumberToBase(value, 2, wordSize);
+
+    case 'oct':
+      return formatBigNumberToBase(value, 8, wordSize);
+
+    case 'hex':
+      return formatBigNumberToBase(value, 16, wordSize);
+
+    case 'auto':
+      {
+        // determine lower and upper bound for exponential notation.
+        // TODO: implement support for upper and lower to be BigNumbers themselves
+        var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3;
+        var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5; // handle special case zero
+
+        if (value.isZero()) return '0'; // determine whether or not to output exponential notation
+
+        var str;
+        var rounded = value.toSignificantDigits(precision);
+        var exp = rounded.e;
+
+        if (exp >= lowerExp && exp < upperExp) {
+          // normal number notation
+          str = rounded.toFixed();
+        } else {
+          // exponential notation
+          str = toExponential(value, precision);
+        } // remove trailing zeros after the decimal point
+
+
+        return str.replace(/((\.\d*?)(0+))($|e)/, function () {
+          var digits = arguments[2];
+          var e = arguments[4];
+          return digits !== '.' ? digits + e : e;
+        });
+      }
+
+    default:
+      throw new Error('Unknown notation "' + notation + '". ' + 'Choose "auto", "exponential", "fixed", "bin", "oct", or "hex.');
+  }
+}
+/**
+ * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param {BigNumber | string} value
+ * @param {number} [precision]        Optional number of significant figures to return.
+ */
+
+
+function toEngineering(value, precision) {
+  // find nearest lower multiple of 3 for exponent
+  var e = value.e;
+  var newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3; // find difference in exponents, and calculate the value without exponent
+
+  var valueWithoutExp = value.mul(Math.pow(10, -newExp));
+  var valueStr = valueWithoutExp.toPrecision(precision);
+
+  if (valueStr.indexOf('e') !== -1) {
+    valueStr = valueWithoutExp.toString();
+  }
+
+  return valueStr + 'e' + (e >= 0 ? '+' : '') + newExp.toString();
+}
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]  Number of digits in formatted output.
+ *                              If not provided, the maximum available digits
+ *                              is used.
+ * @returns {string} str
+ */
+
+
+function toExponential(value, precision) {
+  if (precision !== undefined) {
+    return value.toExponential(precision - 1); // Note the offset of one
+  } else {
+    return value.toExponential();
+  }
+}
+/**
+ * Format a number with fixed notation.
+ * @param {BigNumber} value
+ * @param {number} [precision=undefined] Optional number of decimals after the
+ *                                       decimal point. Undefined by default.
+ */
+
+
+function toFixed(value, precision) {
+  return value.toFixed(precision);
+}

package/dist/node_modules/mathjs/lib/cjs/utils/bignumber/nearlyEqual.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nearlyEqual = nearlyEqual;
+
+/**
+ * Compares two BigNumbers.
+ * @param {BigNumber} x       First value to compare
+ * @param {BigNumber} y       Second value to compare
+ * @param {number} [epsilon]  The maximum relative difference between x and y
+ *                            If epsilon is undefined or null, the function will
+ *                            test whether x and y are exactly equal.
+ * @return {boolean} whether the two numbers are nearly equal
+ */
+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
+
+
+  if (x.eq(y)) {
+    return true;
+  } // NaN
+
+
+  if (x.isNaN() || y.isNaN()) {
+    return false;
+  } // 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 {
+      // use relative error
+      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
+
+
+  return false;
+}

package/dist/node_modules/mathjs/lib/cjs/utils/collection.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.containsCollections = containsCollections;
+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
+ * @returns {boolean} Returns true when the array contains one or multiple
+ *                    collections (Arrays or Matrices). Returns false otherwise.
+ */
+function containsCollections(array) {
+  for (var i = 0; i < array.length; i++) {
+    if ((0, _is.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.
+ * @param {Array | Matrix} 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 {
+      callback(value);
+    }
+  }
+}
+/**
+ * Execute the callback function element wise for each element in array and any
+ * nested array
+ * Returns an array with the results
+ * @param {Array | Matrix} array
+ * @param {Function} callback   The callback is called with two parameters:
+ *                              value1 and value2, which contain the current
+ *                              element of both arrays.
+ * @param {boolean} [skipZeros] Invoke callback function for non-zero values only.
+ *
+ * @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
+    return array.map(function (x) {
+      return deepMap(x, callback, skipZeros);
+    });
+  } else {
+    return callback(array);
+  }
+}
+/**
+ * Reduce a given matrix or array to a new matrix or
+ * array with one less dimension, applying the given
+ * callback in the selected dimension.
+ * @param {Array | Matrix} mat
+ * @param {number} dim
+ * @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
+ * @param {number} dim
+ * @param {Function} 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
+
+
+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 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
+
+      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
+
+        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
+
+          u[i] = mark;
+        } else {
+          // copy value to workspace
+          x[i] = avalues[k];
+        }
+      } 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
+
+        u[i] = mark;
+      }
+    }
+  } else {
+    // 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
+
+      if (w[i] !== mark) {
+        // i is new entry in j
+        w[i] = mark; // add i to pattern of C
+
+        cindex.push(i);
+      } else {
+        // indicate function was called on current row
+        u[i] = mark;
+      }
+    }
+  }
+}

package/dist/node_modules/mathjs/lib/cjs/utils/complex.js

@@ -0,0 +1,20 @@
+"use strict";
+
+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
+ * @param {Complex} x
+ * @param {Complex} y
+ * @param {number} epsilon
+ * @returns {boolean}
+ */
+function complexEquals(x, y, epsilon) {
+  return (0, _number.nearlyEqual)(x.re, y.re, epsilon) && (0, _number.nearlyEqual)(x.im, y.im, epsilon);
+}