@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/csch.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCsch = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var _index = require("../../plain/number/index.js");
+
+var name = 'csch';
+var dependencies = ['typed', 'BigNumber'];
+var createCsch = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      _BigNumber = _ref.BigNumber;
+
+  /**
+   * Calculate the hyperbolic cosecant of a value,
+   * defined as `csch(x) = 1 / sinh(x)`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.csch(x)
+   *
+   * Examples:
+   *
+   *    // csch(x) = 1/ sinh(x)
+   *    math.csch(0.5)       // returns 1.9190347513349437
+   *    1 / math.sinh(0.5)   // returns 1.9190347513349437
+   *
+   * See also:
+   *
+   *    sinh, sech, coth
+   *
+   * @param {number | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | Complex | Array | Matrix} Hyperbolic cosecant of x
+   */
+  return typed(name, {
+    number: _index.cschNumber,
+    Complex: function Complex(x) {
+      return x.csch();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x.sinh());
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function csch is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return (0, _collection.deepMap)(x, this);
+    }
+  });
+});
+exports.createCsch = createCsch;

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/sec.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSec = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var _index = require("../../plain/number/index.js");
+
+var name = 'sec';
+var dependencies = ['typed', 'BigNumber'];
+var createSec = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      _BigNumber = _ref.BigNumber;
+
+  /**
+   * Calculate the secant of a value, defined as `sec(x) = 1/cos(x)`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.sec(x)
+   *
+   * Examples:
+   *
+   *    math.sec(2)      // returns number -2.4029979617223822
+   *    1 / math.cos(2)  // returns number -2.4029979617223822
+   *
+   * See also:
+   *
+   *    cos, csc, cot
+   *
+   * @param {number | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | Complex | Array | Matrix} Secant of x
+   */
+  return typed(name, {
+    number: _index.secNumber,
+    Complex: function Complex(x) {
+      return x.sec();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x.cos());
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function sec is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return (0, _collection.deepMap)(x, this);
+    }
+  });
+});
+exports.createSec = createSec;

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/sech.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSech = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var _index = require("../../plain/number/index.js");
+
+var name = 'sech';
+var dependencies = ['typed', 'BigNumber'];
+var createSech = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      _BigNumber = _ref.BigNumber;
+
+  /**
+   * Calculate the hyperbolic secant of a value,
+   * defined as `sech(x) = 1 / cosh(x)`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.sech(x)
+   *
+   * Examples:
+   *
+   *    // sech(x) = 1/ cosh(x)
+   *    math.sech(0.5)       // returns 0.886818883970074
+   *    1 / math.cosh(0.5)   // returns 0.886818883970074
+   *
+   * See also:
+   *
+   *    cosh, csch, coth
+   *
+   * @param {number | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | Complex | Array | Matrix} Hyperbolic secant of x
+   */
+  return typed(name, {
+    number: _index.sechNumber,
+    Complex: function Complex(x) {
+      return x.sech();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(1).div(x.cosh());
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function sech is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return (0, _collection.deepMap)(x, this);
+    }
+  });
+});
+exports.createSech = createSech;

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/sin.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSin = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var name = 'sin';
+var dependencies = ['typed'];
+var createSin = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+
+  /**
+   * Calculate the sine of a value.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.sin(x)
+   *
+   * Examples:
+   *
+   *    math.sin(2)                      // returns number 0.9092974268256813
+   *    math.sin(math.pi / 4)            // returns number 0.7071067811865475
+   *    math.sin(math.unit(90, 'deg'))   // returns number 1
+   *    math.sin(math.unit(30, 'deg'))   // returns number 0.5
+   *
+   *    const angle = 0.2
+   *    math.pow(math.sin(angle), 2) + math.pow(math.cos(angle), 2) // returns number ~1
+   *
+   * See also:
+   *
+   *    cos, tan
+   *
+   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | BigNumber | Complex | Array | Matrix} Sine of x
+   */
+  return typed(name, {
+    number: Math.sin,
+    Complex: function Complex(x) {
+      return x.sin();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.sin();
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function sin is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since sin(0) = 0
+      return (0, _collection.deepMap)(x, this, true);
+    }
+  });
+});
+exports.createSin = createSin;

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/sinh.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSinh = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var _index = require("../../plain/number/index.js");
+
+var name = 'sinh';
+var dependencies = ['typed'];
+var createSinh = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+
+  /**
+   * Calculate the hyperbolic sine of a value,
+   * defined as `sinh(x) = 1/2 * (exp(x) - exp(-x))`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.sinh(x)
+   *
+   * Examples:
+   *
+   *    math.sinh(0.5)       // returns number 0.5210953054937474
+   *
+   * See also:
+   *
+   *    cosh, tanh
+   *
+   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | BigNumber | Complex | Array | Matrix} Hyperbolic sine of x
+   */
+  return typed(name, {
+    number: _index.sinhNumber,
+    Complex: function Complex(x) {
+      return x.sinh();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.sinh();
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function sinh is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since sinh(0) = 0
+      return (0, _collection.deepMap)(x, this, true);
+    }
+  });
+});
+exports.createSinh = createSinh;

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/tan.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTan = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var name = 'tan';
+var dependencies = ['typed'];
+var createTan = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+
+  /**
+   * Calculate the tangent of a value. `tan(x)` is equal to `sin(x) / cos(x)`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.tan(x)
+   *
+   * Examples:
+   *
+   *    math.tan(0.5)                    // returns number 0.5463024898437905
+   *    math.sin(0.5) / math.cos(0.5)    // returns number 0.5463024898437905
+   *    math.tan(math.pi / 4)            // returns number 1
+   *    math.tan(math.unit(45, 'deg'))   // returns number 1
+   *
+   * See also:
+   *
+   *    atan, sin, cos
+   *
+   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | BigNumber | Complex | Array | Matrix} Tangent of x
+   */
+  return typed(name, {
+    number: Math.tan,
+    Complex: function Complex(x) {
+      return x.tan();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.tan();
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function tan is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since tan(0) = 0
+      return (0, _collection.deepMap)(x, this, true);
+    }
+  });
+});
+exports.createTan = createTan;

package/dist/node_modules/mathjs/lib/cjs/function/trigonometry/tanh.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTanh = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _collection = require("../../utils/collection.js");
+
+var _number = require("../../utils/number.js");
+
+var name = 'tanh';
+var dependencies = ['typed'];
+var createTanh = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+
+  /**
+   * Calculate the hyperbolic tangent of a value,
+   * defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.tanh(x)
+   *
+   * Examples:
+   *
+   *    // tanh(x) = sinh(x) / cosh(x) = 1 / coth(x)
+   *    math.tanh(0.5)                   // returns 0.46211715726000974
+   *    math.sinh(0.5) / math.cosh(0.5)  // returns 0.46211715726000974
+   *    1 / math.coth(0.5)               // returns 0.46211715726000974
+   *
+   * See also:
+   *
+   *    sinh, cosh, coth
+   *
+   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
+   * @return {number | BigNumber | Complex | Array | Matrix} Hyperbolic tangent of x
+   */
+  return typed('tanh', {
+    number: _number.tanh,
+    Complex: function Complex(x) {
+      return x.tanh();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.tanh();
+    },
+    Unit: function Unit(x) {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function tanh is no angle');
+      }
+
+      return this(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since tanh(0) = 0
+      return (0, _collection.deepMap)(x, this, true);
+    }
+  });
+});
+exports.createTanh = createTanh;

package/dist/node_modules/mathjs/lib/cjs/function/unit/to.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTo = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var _algorithm = require("../../type/matrix/utils/algorithm13.js");
+
+var _algorithm2 = require("../../type/matrix/utils/algorithm14.js");
+
+var name = 'to';
+var dependencies = ['typed', 'matrix'];
+var createTo = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      matrix = _ref.matrix;
+  var algorithm13 = (0, _algorithm.createAlgorithm13)({
+    typed: typed
+  });
+  var algorithm14 = (0, _algorithm2.createAlgorithm14)({
+    typed: typed
+  });
+  /**
+   * Change the unit of a value.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.to(x, unit)
+   *
+   * Examples:
+   *
+   *    math.to(math.unit('2 inch'), 'cm')                   // returns Unit 5.08 cm
+   *    math.to(math.unit('2 inch'), math.unit(null, 'cm'))  // returns Unit 5.08 cm
+   *    math.to(math.unit(16, 'bytes'), 'bits')              // returns Unit 128 bits
+   *
+   * See also:
+   *
+   *    unit
+   *
+   * @param {Unit | Array | Matrix} x     The unit to be converted.
+   * @param {Unit | Array | Matrix} unit  New unit. Can be a string like "cm"
+   *                                      or a unit without value.
+   * @return {Unit | Array | Matrix} value with changed, fixed unit.
+   */
+
+  return typed(name, {
+    'Unit, Unit | string': function UnitUnitString(x, unit) {
+      return x.to(unit);
+    },
+    'Matrix, Matrix': function MatrixMatrix(x, y) {
+      // SparseMatrix does not support Units
+      return algorithm13(x, y, this);
+    },
+    'Array, Array': function ArrayArray(x, y) {
+      // use matrix implementation
+      return this(matrix(x), matrix(y)).valueOf();
+    },
+    'Array, Matrix': function ArrayMatrix(x, y) {
+      // use matrix implementation
+      return this(matrix(x), y);
+    },
+    'Matrix, Array': function MatrixArray(x, y) {
+      // use matrix implementation
+      return this(x, matrix(y));
+    },
+    'Matrix, any': function MatrixAny(x, y) {
+      // SparseMatrix does not support Units
+      return algorithm14(x, y, this, false);
+    },
+    'any, Matrix': function anyMatrix(x, y) {
+      // SparseMatrix does not support Units
+      return algorithm14(y, x, this, true);
+    },
+    'Array, any': function ArrayAny(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(x), y, this, false).valueOf();
+    },
+    'any, Array': function anyArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf();
+    }
+  });
+});
+exports.createTo = createTo;

package/dist/node_modules/mathjs/lib/cjs/function/utils/clone.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createClone = void 0;
+
+var _object = require("../../utils/object.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'clone';
+var dependencies = ['typed'];
+var createClone = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+
+  /**
+   * Clone an object. Will make a deep copy of the data.
+   *
+   * Syntax:
+   *
+   *     math.clone(x)
+   *
+   * Examples:
+   *
+   *    math.clone(3.5)                   // returns number 3.5
+   *    math.clone(math.complex('2-4i') // returns Complex 2 - 4i
+   *    math.clone(math.unit(45, 'deg'))  // returns Unit 45 deg
+   *    math.clone([[1, 2], [3, 4]])      // returns Array [[1, 2], [3, 4]]
+   *    math.clone("hello world")         // returns string "hello world"
+   *
+   * @param {*} x   Object to be cloned
+   * @return {*} A clone of object x
+   */
+  return typed(name, {
+    any: _object.clone
+  });
+});
+exports.createClone = createClone;

package/dist/node_modules/mathjs/lib/cjs/function/utils/hasNumericValue.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHasNumericValue = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'hasNumericValue';
+var dependencies = ['typed', 'isNumeric'];
+var createHasNumericValue = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      isNumeric = _ref.isNumeric;
+
+  /**
+   * Test whether a value is an numeric value.
+   *
+   * In case of a string, true is returned if the string contains a numeric value.
+   *
+   * Syntax:
+   *
+   *     math.hasNumericValue(x)
+   *
+   * Examples:
+   *
+   *    math.hasNumericValue(2)                     // returns true
+   *    math.hasNumericValue('2')                   // returns true
+   *    math.isNumeric('2')                         // returns false
+   *    math.hasNumericValue(0)                     // returns true
+   *    math.hasNumericValue(math.bignumber(500))   // returns true
+   *    math.hasNumericValue(math.fraction(4))      // returns true
+   *    math.hasNumericValue(math.complex('2-4i')   // returns false
+   *    math.hasNumericValue([2.3, 'foo', false])   // returns [true, false, true]
+   *
+   * See also:
+   *
+   *    isZero, isPositive, isNegative, isInteger, isNumeric
+   *
+   * @param {*} x       Value to be tested
+   * @return {boolean}  Returns true when `x` is a `number`, `BigNumber`,
+   *                    `Fraction`, `Boolean`, or a `String` containing number. Returns false for other types.
+   *                    Throws an error in case of unknown types.
+   */
+  return typed(name, {
+    string: function string(x) {
+      return x.trim().length > 0 && !isNaN(Number(x));
+    },
+    any: function any(x) {
+      return isNumeric(x);
+    }
+  });
+});
+exports.createHasNumericValue = createHasNumericValue;

package/dist/node_modules/mathjs/lib/cjs/function/utils/isInteger.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsInteger = void 0;
+
+var _collection = require("../../utils/collection.js");
+
+var _number = require("../../utils/number.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'isInteger';
+var dependencies = ['typed'];
+var createIsInteger = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+
+  /**
+   * Test whether a value is an integer number.
+   * The function supports `number`, `BigNumber`, and `Fraction`.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isInteger(x)
+   *
+   * Examples:
+   *
+   *    math.isInteger(2)                     // returns true
+   *    math.isInteger(0)                     // returns true
+   *    math.isInteger(0.5)                   // returns false
+   *    math.isInteger(math.bignumber(500))   // returns true
+   *    math.isInteger(math.fraction(4))      // returns true
+   *    math.isInteger('3')                   // returns true
+   *    math.isInteger([3, 0.5, -2])          // returns [true, false, true]
+   *    math.isInteger(math.complex('2-4i')   // throws an error
+   *
+   * See also:
+   *
+   *    isNumeric, isPositive, isNegative, isZero
+   *
+   * @param {number | BigNumber | Fraction | Array | Matrix} x   Value to be tested
+   * @return {boolean}  Returns true when `x` contains a numeric, integer value.
+   *                    Throws an error in case of an unknown data type.
+   */
+  return typed(name, {
+    number: _number.isInteger,
+    // TODO: what to do with isInteger(add(0.1, 0.2))  ?
+    BigNumber: function BigNumber(x) {
+      return x.isInt();
+    },
+    Fraction: function Fraction(x) {
+      return x.d === 1 && isFinite(x.n);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return (0, _collection.deepMap)(x, this);
+    }
+  });
+});
+exports.createIsInteger = createIsInteger;