mathjs-min 11.7.2

package/lib/cjs/expression/transform/apply.transform.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createApplyTransform = void 0;
+var _errorTransform = require("./utils/errorTransform.js");
+var _factory = require("../../utils/factory.js");
+var _apply = require("../../function/matrix/apply.js");
+var _is = require("../../utils/is.js");
+var name = 'apply';
+var dependencies = ['typed', 'isInteger'];
+
+/**
+ * Attach a transform function to math.apply
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function apply
+ * from one-based to zero based
+ */
+var createApplyTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    isInteger = _ref.isInteger;
+  var apply = (0, _apply.createApply)({
+    typed: typed,
+    isInteger: isInteger
+  });
+
+  // @see: comment of concat itself
+  return typed('apply', {
+    '...any': function any(args) {
+      // change dim from one-based to zero-based
+      var dim = args[1];
+      if ((0, _is.isNumber)(dim)) {
+        args[1] = dim - 1;
+      } else if ((0, _is.isBigNumber)(dim)) {
+        args[1] = dim.minus(1);
+      }
+      try {
+        return apply.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createApplyTransform = createApplyTransform;

package/lib/cjs/expression/transform/column.transform.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createColumnTransform = void 0;
+var _errorTransform = require("./utils/errorTransform.js");
+var _factory = require("../../utils/factory.js");
+var _column = require("../../function/matrix/column.js");
+var _is = require("../../utils/is.js");
+var name = 'column';
+var dependencies = ['typed', 'Index', 'matrix', 'range'];
+
+/**
+ * Attach a transform function to matrix.column
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `index` parameter of function column
+ * from zero-based to one-based
+ */
+var createColumnTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    Index = _ref.Index,
+    matrix = _ref.matrix,
+    range = _ref.range;
+  var column = (0, _column.createColumn)({
+    typed: typed,
+    Index: Index,
+    matrix: matrix,
+    range: range
+  });
+
+  // @see: comment of column itself
+  return typed('column', {
+    '...any': function any(args) {
+      // change last argument from zero-based to one-based
+      var lastIndex = args.length - 1;
+      var last = args[lastIndex];
+      if ((0, _is.isNumber)(last)) {
+        args[lastIndex] = last - 1;
+      }
+      try {
+        return column.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createColumnTransform = createColumnTransform;

package/lib/cjs/expression/transform/concat.transform.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createConcatTransform = void 0;
+var _is = require("../../utils/is.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _factory = require("../../utils/factory.js");
+var _concat = require("../../function/matrix/concat.js");
+var name = 'concat';
+var dependencies = ['typed', 'matrix', 'isInteger'];
+var createConcatTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    isInteger = _ref.isInteger;
+  var concat = (0, _concat.createConcat)({
+    typed: typed,
+    matrix: matrix,
+    isInteger: isInteger
+  });
+
+  /**
+   * Attach a transform function to math.range
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function concat
+   * from one-based to zero based
+   */
+  return typed('concat', {
+    '...any': function any(args) {
+      // change last argument from one-based to zero-based
+      var lastIndex = args.length - 1;
+      var last = args[lastIndex];
+      if ((0, _is.isNumber)(last)) {
+        args[lastIndex] = last - 1;
+      } else if ((0, _is.isBigNumber)(last)) {
+        args[lastIndex] = last.minus(1);
+      }
+      try {
+        return concat.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createConcatTransform = createConcatTransform;

package/lib/cjs/expression/transform/cumsum.transform.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCumSumTransform = void 0;
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _cumsum = require("../../function/statistics/cumsum.js");
+/**
+ * Attach a transform function to math.sum
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `dim` parameter of function sum
+ * from one-based to zero based
+ */
+var name = 'cumsum';
+var dependencies = ['typed', 'add', 'unaryPlus'];
+var createCumSumTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    unaryPlus = _ref.unaryPlus;
+  var cumsum = (0, _cumsum.createCumSum)({
+    typed: typed,
+    add: add,
+    unaryPlus: unaryPlus
+  });
+  return typed(name, {
+    '...any': function any(args) {
+      // change last argument dim from one-based to zero-based
+      if (args.length === 2 && (0, _is.isCollection)(args[0])) {
+        var dim = args[1];
+        if ((0, _is.isNumber)(dim)) {
+          args[1] = dim - 1;
+        } else if ((0, _is.isBigNumber)(dim)) {
+          args[1] = dim.minus(1);
+        }
+      }
+      try {
+        return cumsum.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createCumSumTransform = createCumSumTransform;

package/lib/cjs/expression/transform/diff.transform.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDiffTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _diff = require("../../function/matrix/diff.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+var name = 'diff';
+var dependencies = ['typed', 'matrix', 'subtract', 'number', 'bignumber'];
+var createDiffTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    subtract = _ref.subtract,
+    number = _ref.number,
+    bignumber = _ref.bignumber;
+  var diff = (0, _diff.createDiff)({
+    typed: typed,
+    matrix: matrix,
+    subtract: subtract,
+    number: number,
+    bignumber: bignumber
+  });
+
+  /**
+   * Attach a transform function to math.diff
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a range which includes the end value
+   */
+  return typed(name, {
+    '...any': function any(args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return diff.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createDiffTransform = createDiffTransform;

package/lib/cjs/expression/transform/filter.transform.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFilterTransform = void 0;
+var _is = require("../../utils/is.js");
+var _array = require("../../utils/array.js");
+var _function = require("../../utils/function.js");
+var _compileInlineExpression = require("./utils/compileInlineExpression.js");
+var _factory = require("../../utils/factory.js");
+var name = 'filter';
+var dependencies = ['typed'];
+var createFilterTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Attach a transform function to math.filter
+   * Adds a property transform containing the transform function.
+   *
+   * This transform adds support for equations as test function for math.filter,
+   * so you can do something like 'filter([3, -2, 5], x > 0)'.
+   */
+  function filterTransform(args, math, scope) {
+    var x, callback;
+    if (args[0]) {
+      x = args[0].compile().evaluate(scope);
+    }
+    if (args[1]) {
+      if ((0, _is.isSymbolNode)(args[1]) || (0, _is.isFunctionAssignmentNode)(args[1])) {
+        // a function pointer, like filter([3, -2, 5], myTestFunction)
+        callback = args[1].compile().evaluate(scope);
+      } else {
+        // an expression like filter([3, -2, 5], x > 0)
+        callback = (0, _compileInlineExpression.compileInlineExpression)(args[1], math, scope);
+      }
+    }
+    return filter(x, callback);
+  }
+  filterTransform.rawArgs = true;
+
+  // one based version of function filter
+  var filter = typed('filter', {
+    'Array, function': _filter,
+    'Matrix, function': function MatrixFunction(x, test) {
+      return x.create(_filter(x.toArray(), test));
+    },
+    'Array, RegExp': _array.filterRegExp,
+    'Matrix, RegExp': function MatrixRegExp(x, test) {
+      return x.create((0, _array.filterRegExp)(x.toArray(), test));
+    }
+  });
+  return filterTransform;
+}, {
+  isTransformFunction: true
+});
+
+/**
+ * Filter values in a callback given a callback function
+ *
+ * !!! Passes a one-based index !!!
+ *
+ * @param {Array} x
+ * @param {Function} callback
+ * @return {Array} Returns the filtered array
+ * @private
+ */
+exports.createFilterTransform = createFilterTransform;
+function _filter(x, callback) {
+  // figure out what number of arguments the callback function expects
+  var args = (0, _function.maxArgumentCount)(callback);
+  return (0, _array.filter)(x, function (value, index, array) {
+    // invoke the callback function with the right number of arguments
+    if (args === 1) {
+      return callback(value);
+    } else if (args === 2) {
+      return callback(value, [index + 1]);
+    } else {
+      // 3 or -1
+      return callback(value, [index + 1], array);
+    }
+  });
+}

package/lib/cjs/expression/transform/forEach.transform.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createForEachTransform = void 0;
+var _is = require("../../utils/is.js");
+var _function = require("../../utils/function.js");
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var _compileInlineExpression = require("./utils/compileInlineExpression.js");
+var name = 'forEach';
+var dependencies = ['typed'];
+var createForEachTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Attach a transform function to math.forEach
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a one-based index instead of a zero-based index
+   */
+  function forEachTransform(args, math, scope) {
+    var x, callback;
+    if (args[0]) {
+      x = args[0].compile().evaluate(scope);
+    }
+    if (args[1]) {
+      if ((0, _is.isSymbolNode)(args[1]) || (0, _is.isFunctionAssignmentNode)(args[1])) {
+        // a function pointer, like forEach([3, -2, 5], myTestFunction)
+        callback = args[1].compile().evaluate(scope);
+      } else {
+        // an expression like forEach([3, -2, 5], x > 0 ? callback1(x) : callback2(x) )
+        callback = (0, _compileInlineExpression.compileInlineExpression)(args[1], math, scope);
+      }
+    }
+    return _forEach(x, callback);
+  }
+  forEachTransform.rawArgs = true;
+
+  // one-based version of forEach
+  var _forEach = typed('forEach', {
+    'Array | Matrix, function': function ArrayMatrixFunction(array, callback) {
+      // figure out what number of arguments the callback function expects
+      var args = (0, _function.maxArgumentCount)(callback);
+      var recurse = function recurse(value, index) {
+        if (Array.isArray(value)) {
+          (0, _array.forEach)(value, function (child, i) {
+            // we create a copy of the index array and append the new index value
+            recurse(child, index.concat(i + 1)); // one based index, hence i+1
+          });
+        } else {
+          // invoke the callback function with the right number of arguments
+          if (args === 1) {
+            callback(value);
+          } else if (args === 2) {
+            callback(value, index);
+          } else {
+            // 3 or -1
+            callback(value, index, array);
+          }
+        }
+      };
+      recurse(array.valueOf(), []); // pass Array
+    }
+  });
+
+  return forEachTransform;
+}, {
+  isTransformFunction: true
+});
+exports.createForEachTransform = createForEachTransform;

package/lib/cjs/expression/transform/index.transform.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIndexTransform = void 0;
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var name = 'index';
+var dependencies = ['Index'];
+var createIndexTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var Index = _ref.Index;
+  /**
+   * Attach a transform function to math.index
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a one-based index instead of a zero-based index
+   */
+  return function indexTransform() {
+    var args = [];
+    for (var i = 0, ii = arguments.length; i < ii; i++) {
+      var arg = arguments[i];
+
+      // change from one-based to zero based, and convert BigNumber to number
+      if ((0, _is.isRange)(arg)) {
+        arg.start--;
+        arg.end -= arg.step > 0 ? 0 : 2;
+      } else if (arg && arg.isSet === true) {
+        arg = arg.map(function (v) {
+          return v - 1;
+        });
+      } else if ((0, _is.isArray)(arg) || (0, _is.isMatrix)(arg)) {
+        arg = arg.map(function (v) {
+          return v - 1;
+        });
+      } else if ((0, _is.isNumber)(arg)) {
+        arg--;
+      } else if ((0, _is.isBigNumber)(arg)) {
+        arg = arg.toNumber() - 1;
+      } else if (typeof arg === 'string') {
+        // leave as is
+      } else {
+        throw new TypeError('Dimension must be an Array, Matrix, number, string, or Range');
+      }
+      args[i] = arg;
+    }
+    var res = new Index();
+    Index.apply(res, args);
+    return res;
+  };
+}, {
+  isTransformFunction: true
+});
+exports.createIndexTransform = createIndexTransform;

package/lib/cjs/expression/transform/map.transform.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMapTransform = void 0;
+var _is = require("../../utils/is.js");
+var _function = require("../../utils/function.js");
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var _compileInlineExpression = require("./utils/compileInlineExpression.js");
+var name = 'map';
+var dependencies = ['typed'];
+var createMapTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Attach a transform function to math.map
+   * Adds a property transform containing the transform function.
+   *
+   * This transform creates a one-based index instead of a zero-based index
+   */
+  function mapTransform(args, math, scope) {
+    var x, callback;
+    if (args[0]) {
+      x = args[0].compile().evaluate(scope);
+    }
+    if (args[1]) {
+      if ((0, _is.isSymbolNode)(args[1]) || (0, _is.isFunctionAssignmentNode)(args[1])) {
+        // a function pointer, like filter([3, -2, 5], myTestFunction)
+        callback = args[1].compile().evaluate(scope);
+      } else {
+        // an expression like filter([3, -2, 5], x > 0)
+        callback = (0, _compileInlineExpression.compileInlineExpression)(args[1], math, scope);
+      }
+    }
+    return map(x, callback);
+  }
+  mapTransform.rawArgs = true;
+
+  // one-based version of map function
+  var map = typed('map', {
+    'Array, function': function ArrayFunction(x, callback) {
+      return _map(x, callback, x);
+    },
+    'Matrix, function': function MatrixFunction(x, callback) {
+      return x.create(_map(x.valueOf(), callback, x));
+    }
+  });
+  return mapTransform;
+}, {
+  isTransformFunction: true
+});
+
+/**
+ * Map for a multi dimensional array. One-based indexes
+ * @param {Array} array
+ * @param {function} callback
+ * @param {Array} orig
+ * @return {Array}
+ * @private
+ */
+exports.createMapTransform = createMapTransform;
+function _map(array, callback, orig) {
+  // figure out what number of arguments the callback function expects
+  var argsCount = (0, _function.maxArgumentCount)(callback);
+  function recurse(value, index) {
+    if (Array.isArray(value)) {
+      return (0, _array.map)(value, function (child, i) {
+        // we create a copy of the index array and append the new index value
+        return recurse(child, index.concat(i + 1)); // one based index, hence i + 1
+      });
+    } else {
+      // invoke the (typed) callback function with the right number of arguments
+      if (argsCount === 1) {
+        return callback(value);
+      } else if (argsCount === 2) {
+        return callback(value, index);
+      } else {
+        // 3 or -1
+        return callback(value, index, orig);
+      }
+    }
+  }
+  return recurse(array, []);
+}

package/lib/cjs/expression/transform/max.transform.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMaxTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _max = require("../../function/statistics/max.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+var name = 'max';
+var dependencies = ['typed', 'config', 'numeric', 'larger'];
+var createMaxTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    numeric = _ref.numeric,
+    larger = _ref.larger;
+  var max = (0, _max.createMax)({
+    typed: typed,
+    config: config,
+    numeric: numeric,
+    larger: larger
+  });
+
+  /**
+   * Attach a transform function to math.max
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function max
+   * from one-based to zero based
+   */
+  return typed('max', {
+    '...any': function any(args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return max.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createMaxTransform = createMaxTransform;

package/lib/cjs/expression/transform/mean.transform.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMeanTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _mean = require("../../function/statistics/mean.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+var name = 'mean';
+var dependencies = ['typed', 'add', 'divide'];
+var createMeanTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    divide = _ref.divide;
+  var mean = (0, _mean.createMean)({
+    typed: typed,
+    add: add,
+    divide: divide
+  });
+
+  /**
+   * Attach a transform function to math.mean
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function mean
+   * from one-based to zero based
+   */
+  return typed('mean', {
+    '...any': function any(args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return mean.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createMeanTransform = createMeanTransform;

package/lib/cjs/expression/transform/min.transform.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMinTransform = void 0;
+var _factory = require("../../utils/factory.js");
+var _errorTransform = require("./utils/errorTransform.js");
+var _min = require("../../function/statistics/min.js");
+var _lastDimToZeroBase = require("./utils/lastDimToZeroBase.js");
+var name = 'min';
+var dependencies = ['typed', 'config', 'numeric', 'smaller'];
+var createMinTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    numeric = _ref.numeric,
+    smaller = _ref.smaller;
+  var min = (0, _min.createMin)({
+    typed: typed,
+    config: config,
+    numeric: numeric,
+    smaller: smaller
+  });
+
+  /**
+   * Attach a transform function to math.min
+   * Adds a property transform containing the transform function.
+   *
+   * This transform changed the last `dim` parameter of function min
+   * from one-based to zero based
+   */
+  return typed('min', {
+    '...any': function any(args) {
+      args = (0, _lastDimToZeroBase.lastDimToZeroBase)(args);
+      try {
+        return min.apply(null, args);
+      } catch (err) {
+        throw (0, _errorTransform.errorTransform)(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});
+exports.createMinTransform = createMinTransform;