@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/expression/transform/apply.transform.js

@@ -0,0 +1,45 @@
+import { errorTransform } from './utils/errorTransform.js';
+import { factory } from '../../utils/factory.js';
+import { createApply } from '../../function/matrix/apply.js';
+import { isBigNumber, isNumber } from '../../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
+ */
+
+export var createApplyTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isInteger
+  } = _ref;
+  var apply = createApply({
+    typed,
+    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 (isNumber(dim)) {
+        args[1] = dim - 1;
+      } else if (isBigNumber(dim)) {
+        args[1] = dim.minus(1);
+      }
+
+      try {
+        return apply.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/column.transform.js

@@ -0,0 +1,48 @@
+import { errorTransform } from './utils/errorTransform.js';
+import { factory } from '../../utils/factory.js';
+import { createColumn } from '../../function/matrix/column.js';
+import { isNumber } from '../../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
+ */
+
+export var createColumnTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Index,
+    matrix,
+    range
+  } = _ref;
+  var column = createColumn({
+    typed,
+    Index,
+    matrix,
+    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 (isNumber(last)) {
+        args[lastIndex] = last - 1;
+      }
+
+      try {
+        return column.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/concat.transform.js

@@ -0,0 +1,47 @@
+import { isBigNumber, isNumber } from '../../utils/is.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { factory } from '../../utils/factory.js';
+import { createConcat } from '../../function/matrix/concat.js';
+var name = 'concat';
+var dependencies = ['typed', 'matrix', 'isInteger'];
+export var createConcatTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    isInteger
+  } = _ref;
+  var concat = createConcat({
+    typed,
+    matrix,
+    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 (isNumber(last)) {
+        args[lastIndex] = last - 1;
+      } else if (isBigNumber(last)) {
+        args[lastIndex] = last.minus(1);
+      }
+
+      try {
+        return concat.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/cumsum.transform.js

@@ -0,0 +1,48 @@
+import { isBigNumber, isCollection, isNumber } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createCumSum } from '../../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'];
+export var createCumSumTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    unaryPlus
+  } = _ref;
+  var cumsum = createCumSum({
+    typed,
+    add,
+    unaryPlus
+  });
+  return typed(name, {
+    '...any': function any(args) {
+      // change last argument dim from one-based to zero-based
+      if (args.length === 2 && isCollection(args[0])) {
+        var dim = args[1];
+
+        if (isNumber(dim)) {
+          args[1] = dim - 1;
+        } else if (isBigNumber(dim)) {
+          args[1] = dim.minus(1);
+        }
+      }
+
+      try {
+        return cumsum.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/diff.transform.js

@@ -0,0 +1,42 @@
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createDiff } from '../../function/matrix/diff.js';
+import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
+var name = 'diff';
+var dependencies = ['typed', 'matrix', 'subtract', 'number', 'bignumber'];
+export var createDiffTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    subtract,
+    number,
+    bignumber
+  } = _ref;
+  var diff = createDiff({
+    typed,
+    matrix,
+    subtract,
+    number,
+    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 = lastDimToZeroBase(args);
+
+      try {
+        return diff.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/filter.transform.js

@@ -0,0 +1,81 @@
+import { isFunctionAssignmentNode, isSymbolNode } from '../../utils/is.js';
+import { filter, filterRegExp } from '../../utils/array.js';
+import { maxArgumentCount } from '../../utils/function.js';
+import { compileInlineExpression } from './utils/compileInlineExpression.js';
+import { factory } from '../../utils/factory.js';
+var name = 'filter';
+var dependencies = ['typed'];
+export var createFilterTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+
+  /**
+   * 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 (isSymbolNode(args[1]) || 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 = 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': filterRegExp,
+    'Matrix, RegExp': function MatrixRegExp(x, test) {
+      return x.create(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
+ */
+
+function _filter(x, callback) {
+  // figure out what number of arguments the callback function expects
+  var args = maxArgumentCount(callback);
+  return 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/dist/node_modules/mathjs/lib/esm/expression/transform/forEach.transform.js

@@ -0,0 +1,72 @@
+import { isFunctionAssignmentNode, isSymbolNode } from '../../utils/is.js';
+import { maxArgumentCount } from '../../utils/function.js';
+import { forEach } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { compileInlineExpression } from './utils/compileInlineExpression.js';
+var name = 'forEach';
+var dependencies = ['typed'];
+export var createForEachTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+
+  /**
+   * 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 (isSymbolNode(args[1]) || 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 = 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 = maxArgumentCount(callback);
+
+      var recurse = function recurse(value, index) {
+        if (Array.isArray(value)) {
+          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
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/index.transform.js

@@ -0,0 +1,51 @@
+import { isArray, isBigNumber, isMatrix, isNumber, isRange } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'index';
+var dependencies = ['Index'];
+export var createIndexTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    Index
+  } = _ref;
+
+  /**
+   * 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 (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 (isArray(arg) || isMatrix(arg)) {
+        arg = arg.map(function (v) {
+          return v - 1;
+        });
+      } else if (isNumber(arg)) {
+        arg--;
+      } else if (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
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/map.transform.js

@@ -0,0 +1,86 @@
+import { isFunctionAssignmentNode, isSymbolNode } from '../../utils/is.js';
+import { maxArgumentCount } from '../../utils/function.js';
+import { map } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { compileInlineExpression } from './utils/compileInlineExpression.js';
+var name = 'map';
+var dependencies = ['typed'];
+export var createMapTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+
+  /**
+   * 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 (isSymbolNode(args[1]) || 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 = 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
+ */
+
+function _map(array, callback, orig) {
+  // figure out what number of arguments the callback function expects
+  var argsCount = maxArgumentCount(callback);
+
+  function recurse(value, index) {
+    if (Array.isArray(value)) {
+      return 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/dist/node_modules/mathjs/lib/esm/expression/transform/max.transform.js

@@ -0,0 +1,41 @@
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createMax } from '../../function/statistics/max.js';
+import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
+var name = 'max';
+var dependencies = ['typed', 'config', 'numeric', 'larger'];
+export var createMaxTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    numeric,
+    larger
+  } = _ref;
+  var max = createMax({
+    typed,
+    config,
+    numeric,
+    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 = lastDimToZeroBase(args);
+
+      try {
+        return max.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/mean.transform.js

@@ -0,0 +1,39 @@
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createMean } from '../../function/statistics/mean.js';
+import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
+var name = 'mean';
+var dependencies = ['typed', 'add', 'divide'];
+export var createMeanTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    divide
+  } = _ref;
+  var mean = createMean({
+    typed,
+    add,
+    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 = lastDimToZeroBase(args);
+
+      try {
+        return mean.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});

package/dist/node_modules/mathjs/lib/esm/expression/transform/min.transform.js

@@ -0,0 +1,41 @@
+import { factory } from '../../utils/factory.js';
+import { errorTransform } from './utils/errorTransform.js';
+import { createMin } from '../../function/statistics/min.js';
+import { lastDimToZeroBase } from './utils/lastDimToZeroBase.js';
+var name = 'min';
+var dependencies = ['typed', 'config', 'numeric', 'smaller'];
+export var createMinTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    numeric,
+    smaller
+  } = _ref;
+  var min = createMin({
+    typed,
+    config,
+    numeric,
+    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 = lastDimToZeroBase(args);
+
+      try {
+        return min.apply(null, args);
+      } catch (err) {
+        throw errorTransform(err);
+      }
+    }
+  });
+}, {
+  isTransformFunction: true
+});