@tachybase/plugin-evaluator-mathjs 1.3.20

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

@@ -0,0 +1,682 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arraySize = arraySize;
+exports.contains = contains;
+exports.filter = filter;
+exports.filterRegExp = filterRegExp;
+exports.flatten = flatten;
+exports.forEach = forEach;
+exports.generalize = generalize;
+exports.getArrayDataType = getArrayDataType;
+exports.identify = identify;
+exports.initial = initial;
+exports.join = join;
+exports.last = last;
+exports.map = map;
+exports.processSizesWildcard = processSizesWildcard;
+exports.reshape = reshape;
+exports.resize = resize;
+exports.squeeze = squeeze;
+exports.unsqueeze = unsqueeze;
+exports.validate = validate;
+exports.validateIndex = validateIndex;
+
+var _number = require("./number.js");
+
+var _is = require("./is.js");
+
+var _string = require("./string.js");
+
+var _DimensionError = require("../error/DimensionError.js");
+
+var _IndexError = require("../error/IndexError.js");
+
+/**
+ * Calculate the size of a multi dimensional array.
+ * This function checks the size of the first entry, it does not validate
+ * whether all dimensions match. (use function `validate` for that)
+ * @param {Array} x
+ * @Return {Number[]} size
+ */
+function arraySize(x) {
+  var s = [];
+
+  while (Array.isArray(x)) {
+    s.push(x.length);
+    x = x[0];
+  }
+
+  return s;
+}
+/**
+ * Recursively validate whether each element in a multi dimensional array
+ * has a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @param {number} dim   Current dimension
+ * @throws DimensionError
+ * @private
+ */
+
+
+function _validate(array, size, dim) {
+  var i;
+  var len = array.length;
+
+  if (len !== size[dim]) {
+    throw new _DimensionError.DimensionError(len, size[dim]);
+  }
+
+  if (dim < size.length - 1) {
+    // recursively validate each child array
+    var dimNext = dim + 1;
+
+    for (i = 0; i < len; i++) {
+      var child = array[i];
+
+      if (!Array.isArray(child)) {
+        throw new _DimensionError.DimensionError(size.length - 1, size.length, '<');
+      }
+
+      _validate(array[i], size, dimNext);
+    }
+  } else {
+    // last dimension. none of the childs may be an array
+    for (i = 0; i < len; i++) {
+      if (Array.isArray(array[i])) {
+        throw new _DimensionError.DimensionError(size.length + 1, size.length, '>');
+      }
+    }
+  }
+}
+/**
+ * Validate whether each element in a multi dimensional array has
+ * a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @throws DimensionError
+ */
+
+
+function validate(array, size) {
+  var isScalar = size.length === 0;
+
+  if (isScalar) {
+    // scalar
+    if (Array.isArray(array)) {
+      throw new _DimensionError.DimensionError(array.length, 0);
+    }
+  } else {
+    // array
+    _validate(array, size, 0);
+  }
+}
+/**
+ * Test whether index is an integer number with index >= 0 and index < length
+ * when length is provided
+ * @param {number} index    Zero-based index
+ * @param {number} [length] Length of the array
+ */
+
+
+function validateIndex(index, length) {
+  if (!(0, _is.isNumber)(index) || !(0, _number.isInteger)(index)) {
+    throw new TypeError('Index must be an integer (value: ' + index + ')');
+  }
+
+  if (index < 0 || typeof length === 'number' && index >= length) {
+    throw new _IndexError.IndexError(index, length);
+  }
+}
+/**
+ * Resize a multi dimensional array. The resized array is returned.
+ * @param {Array} array         Array to be resized
+ * @param {Array.<number>} size Array with the size of each dimension
+ * @param {*} [defaultValue=0]  Value to be filled in in new entries,
+ *                              zero by default. Specify for example `null`,
+ *                              to clearly see entries that are not explicitly
+ *                              set.
+ * @return {Array} array         The resized array
+ */
+
+
+function resize(array, size, defaultValue) {
+  // TODO: add support for scalars, having size=[] ?
+  // check the type of the arguments
+  if (!Array.isArray(array) || !Array.isArray(size)) {
+    throw new TypeError('Array expected');
+  }
+
+  if (size.length === 0) {
+    throw new Error('Resizing to scalar is not supported');
+  } // check whether size contains positive integers
+
+
+  size.forEach(function (value) {
+    if (!(0, _is.isNumber)(value) || !(0, _number.isInteger)(value) || value < 0) {
+      throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + (0, _string.format)(size) + ')');
+    }
+  }); // recursively resize the array
+
+  var _defaultValue = defaultValue !== undefined ? defaultValue : 0;
+
+  _resize(array, size, 0, _defaultValue);
+
+  return array;
+}
+/**
+ * Recursively resize a multi dimensional array
+ * @param {Array} array         Array to be resized
+ * @param {number[]} size       Array with the size of each dimension
+ * @param {number} dim          Current dimension
+ * @param {*} [defaultValue]    Value to be filled in in new entries,
+ *                              undefined by default.
+ * @private
+ */
+
+
+function _resize(array, size, dim, defaultValue) {
+  var i;
+  var elem;
+  var oldLen = array.length;
+  var newLen = size[dim];
+  var minLen = Math.min(oldLen, newLen); // apply new length
+
+  array.length = newLen;
+
+  if (dim < size.length - 1) {
+    // non-last dimension
+    var dimNext = dim + 1; // resize existing child arrays
+
+    for (i = 0; i < minLen; i++) {
+      // resize child array
+      elem = array[i];
+
+      if (!Array.isArray(elem)) {
+        elem = [elem]; // add a dimension
+
+        array[i] = elem;
+      }
+
+      _resize(elem, size, dimNext, defaultValue);
+    } // create new child arrays
+
+
+    for (i = minLen; i < newLen; i++) {
+      // get child array
+      elem = [];
+      array[i] = elem; // resize new child array
+
+      _resize(elem, size, dimNext, defaultValue);
+    }
+  } else {
+    // last dimension
+    // remove dimensions of existing values
+    for (i = 0; i < minLen; i++) {
+      while (Array.isArray(array[i])) {
+        array[i] = array[i][0];
+      }
+    } // fill new elements with the default value
+
+
+    for (i = minLen; i < newLen; i++) {
+      array[i] = defaultValue;
+    }
+  }
+}
+/**
+ * Re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ *
+ * @throws {DimensionError}       If the product of the new dimension sizes does
+ *                                not equal that of the old ones
+ */
+
+
+function reshape(array, sizes) {
+  var flatArray = flatten(array);
+  var currentLength = flatArray.length;
+
+  if (!Array.isArray(array) || !Array.isArray(sizes)) {
+    throw new TypeError('Array expected');
+  }
+
+  if (sizes.length === 0) {
+    throw new _DimensionError.DimensionError(0, currentLength, '!=');
+  }
+
+  sizes = processSizesWildcard(sizes, currentLength);
+  var newLength = product(sizes);
+
+  if (currentLength !== newLength) {
+    throw new _DimensionError.DimensionError(newLength, currentLength, '!=');
+  }
+
+  try {
+    return _reshape(flatArray, sizes);
+  } catch (e) {
+    if (e instanceof _DimensionError.DimensionError) {
+      throw new _DimensionError.DimensionError(newLength, currentLength, '!=');
+    }
+
+    throw e;
+  }
+}
+/**
+ * Replaces the wildcard -1 in the sizes array.
+ * @param {Array.<number>} sizes  List of sizes for each dimension. At most on wildcard.
+ * @param {number} currentLength  Number of elements in the array.
+ * @throws {Error}                If more than one wildcard or unable to replace it.
+ * @returns {Array.<number>}      The sizes array with wildcard replaced.
+ */
+
+
+function processSizesWildcard(sizes, currentLength) {
+  var newLength = product(sizes);
+  var processedSizes = sizes.slice();
+  var WILDCARD = -1;
+  var wildCardIndex = sizes.indexOf(WILDCARD);
+  var isMoreThanOneWildcard = sizes.indexOf(WILDCARD, wildCardIndex + 1) >= 0;
+
+  if (isMoreThanOneWildcard) {
+    throw new Error('More than one wildcard in sizes');
+  }
+
+  var hasWildcard = wildCardIndex >= 0;
+  var canReplaceWildcard = currentLength % newLength === 0;
+
+  if (hasWildcard) {
+    if (canReplaceWildcard) {
+      processedSizes[wildCardIndex] = -currentLength / newLength;
+    } else {
+      throw new Error('Could not replace wildcard, since ' + currentLength + ' is no multiple of ' + -newLength);
+    }
+  }
+
+  return processedSizes;
+}
+/**
+ * Computes the product of all array elements.
+ * @param {Array<number>} array Array of factors
+ * @returns {number}            Product of all elements
+ */
+
+
+function product(array) {
+  return array.reduce(function (prev, curr) {
+    return prev * curr;
+  }, 1);
+}
+/**
+ * Iteratively re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {Array.<number>} sizes  List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ */
+
+
+function _reshape(array, sizes) {
+  // testing if there are enough elements for the requested shape
+  var tmpArray = array;
+  var tmpArray2; // for each dimensions starting by the last one and ignoring the first one
+
+  for (var sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
+    var size = sizes[sizeIndex];
+    tmpArray2 = []; // aggregate the elements of the current tmpArray in elements of the requested size
+
+    var length = tmpArray.length / size;
+
+    for (var i = 0; i < length; i++) {
+      tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size));
+    } // set it as the new tmpArray for the next loop turn or for return
+
+
+    tmpArray = tmpArray2;
+  }
+
+  return tmpArray;
+}
+/**
+ * Squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {Array} [size]
+ * @returns {Array} returns the array itself
+ */
+
+
+function squeeze(array, size) {
+  var s = size || arraySize(array); // squeeze outer dimensions
+
+  while (Array.isArray(array) && array.length === 1) {
+    array = array[0];
+    s.shift();
+  } // find the first dimension to be squeezed
+
+
+  var dims = s.length;
+
+  while (s[dims - 1] === 1) {
+    dims--;
+  } // squeeze inner dimensions
+
+
+  if (dims < s.length) {
+    array = _squeeze(array, dims, 0);
+    s.length = dims;
+  }
+
+  return array;
+}
+/**
+ * Recursively squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {number} dims Required number of dimensions
+ * @param {number} dim  Current dimension
+ * @returns {Array | *} Returns the squeezed array
+ * @private
+ */
+
+
+function _squeeze(array, dims, dim) {
+  var i, ii;
+
+  if (dim < dims) {
+    var next = dim + 1;
+
+    for (i = 0, ii = array.length; i < ii; i++) {
+      array[i] = _squeeze(array[i], dims, next);
+    }
+  } else {
+    while (Array.isArray(array)) {
+      array = array[0];
+    }
+  }
+
+  return array;
+}
+/**
+ * Unsqueeze a multi dimensional array: add dimensions when missing
+ *
+ * Paramter `size` will be mutated to match the new, unqueezed matrix size.
+ *
+ * @param {Array} array
+ * @param {number} dims       Desired number of dimensions of the array
+ * @param {number} [outer]    Number of outer dimensions to be added
+ * @param {Array} [size] Current size of array.
+ * @returns {Array} returns the array itself
+ * @private
+ */
+
+
+function unsqueeze(array, dims, outer, size) {
+  var s = size || arraySize(array); // unsqueeze outer dimensions
+
+  if (outer) {
+    for (var i = 0; i < outer; i++) {
+      array = [array];
+      s.unshift(1);
+    }
+  } // unsqueeze inner dimensions
+
+
+  array = _unsqueeze(array, dims, 0);
+
+  while (s.length < dims) {
+    s.push(1);
+  }
+
+  return array;
+}
+/**
+ * Recursively unsqueeze a multi dimensional array
+ * @param {Array} array
+ * @param {number} dims Required number of dimensions
+ * @param {number} dim  Current dimension
+ * @returns {Array | *} Returns the squeezed array
+ * @private
+ */
+
+
+function _unsqueeze(array, dims, dim) {
+  var i, ii;
+
+  if (Array.isArray(array)) {
+    var next = dim + 1;
+
+    for (i = 0, ii = array.length; i < ii; i++) {
+      array[i] = _unsqueeze(array[i], dims, next);
+    }
+  } else {
+    for (var d = dim; d < dims; d++) {
+      array = [array];
+    }
+  }
+
+  return array;
+}
+/**
+ * Flatten a multi dimensional array, put all elements in a one dimensional
+ * array
+ * @param {Array} array   A multi dimensional array
+ * @return {Array}        The flattened array (1 dimensional)
+ */
+
+
+function flatten(array) {
+  if (!Array.isArray(array)) {
+    // if not an array, return as is
+    return array;
+  }
+
+  var flat = [];
+  array.forEach(function callback(value) {
+    if (Array.isArray(value)) {
+      value.forEach(callback); // traverse through sub-arrays recursively
+    } else {
+      flat.push(value);
+    }
+  });
+  return flat;
+}
+/**
+ * A safe map
+ * @param {Array} array
+ * @param {function} callback
+ */
+
+
+function map(array, callback) {
+  return Array.prototype.map.call(array, callback);
+}
+/**
+ * A safe forEach
+ * @param {Array} array
+ * @param {function} callback
+ */
+
+
+function forEach(array, callback) {
+  Array.prototype.forEach.call(array, callback);
+}
+/**
+ * A safe filter
+ * @param {Array} array
+ * @param {function} callback
+ */
+
+
+function filter(array, callback) {
+  if (arraySize(array).length !== 1) {
+    throw new Error('Only one dimensional matrices supported');
+  }
+
+  return Array.prototype.filter.call(array, callback);
+}
+/**
+ * Filter values in a callback given a regular expression
+ * @param {Array} array
+ * @param {RegExp} regexp
+ * @return {Array} Returns the filtered array
+ * @private
+ */
+
+
+function filterRegExp(array, regexp) {
+  if (arraySize(array).length !== 1) {
+    throw new Error('Only one dimensional matrices supported');
+  }
+
+  return Array.prototype.filter.call(array, function (entry) {
+    return regexp.test(entry);
+  });
+}
+/**
+ * A safe join
+ * @param {Array} array
+ * @param {string} separator
+ */
+
+
+function join(array, separator) {
+  return Array.prototype.join.call(array, separator);
+}
+/**
+ * Assign a numeric identifier to every element of a sorted array
+ * @param {Array} a  An array
+ * @return {Array} An array of objects containing the original value and its identifier
+ */
+
+
+function identify(a) {
+  if (!Array.isArray(a)) {
+    throw new TypeError('Array input expected');
+  }
+
+  if (a.length === 0) {
+    return a;
+  }
+
+  var b = [];
+  var count = 0;
+  b[0] = {
+    value: a[0],
+    identifier: 0
+  };
+
+  for (var i = 1; i < a.length; i++) {
+    if (a[i] === a[i - 1]) {
+      count++;
+    } else {
+      count = 0;
+    }
+
+    b.push({
+      value: a[i],
+      identifier: count
+    });
+  }
+
+  return b;
+}
+/**
+ * Remove the numeric identifier from the elements
+ * @param {array} a  An array
+ * @return {array} An array of values without identifiers
+ */
+
+
+function generalize(a) {
+  if (!Array.isArray(a)) {
+    throw new TypeError('Array input expected');
+  }
+
+  if (a.length === 0) {
+    return a;
+  }
+
+  var b = [];
+
+  for (var i = 0; i < a.length; i++) {
+    b.push(a[i].value);
+  }
+
+  return b;
+}
+/**
+ * Check the datatype of a given object
+ * This is a low level implementation that should only be used by
+ * parent Matrix classes such as SparseMatrix or DenseMatrix
+ * This method does not validate Array Matrix shape
+ * @param {Array} array
+ * @param {function} typeOf   Callback function to use to determine the type of a value
+ * @return {string}
+ */
+
+
+function getArrayDataType(array, typeOf) {
+  var type; // to hold type info
+
+  var length = 0; // to hold length value to ensure it has consistent sizes
+
+  for (var i = 0; i < array.length; i++) {
+    var item = array[i];
+    var isArray = Array.isArray(item); // Saving the target matrix row size
+
+    if (i === 0 && isArray) {
+      length = item.length;
+    } // If the current item is an array but the length does not equal the targetVectorSize
+
+
+    if (isArray && item.length !== length) {
+      return undefined;
+    }
+
+    var itemType = isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
+    : typeOf(item);
+
+    if (type === undefined) {
+      type = itemType; // first item
+    } else if (type !== itemType) {
+      return 'mixed';
+    } else {// we're good, everything has the same type so far
+    }
+  }
+
+  return type;
+}
+/**
+ * Return the last item from an array
+ * @param array
+ * @returns {*}
+ */
+
+
+function last(array) {
+  return array[array.length - 1];
+}
+/**
+ * Get all but the last element of array.
+ */
+
+
+function initial(array) {
+  return array.slice(0, array.length - 1);
+}
+/**
+ * Test whether an array or string contains an item
+ * @param {Array | string} array
+ * @param {*} item
+ * @return {boolean}
+ */
+
+
+function contains(array, item) {
+  return array.indexOf(item) !== -1;
+}