@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/function/arithmetic/cbrt.js

@@ -0,0 +1,141 @@
+import { factory } from '../../utils/factory.js';
+import { isBigNumber, isComplex, isFraction } from '../../utils/is.js';
+import { deepMap } from '../../utils/collection.js';
+import { cbrtNumber } from '../../plain/number/index.js';
+var name = 'cbrt';
+var dependencies = ['config', 'typed', 'isNegative', 'unaryMinus', 'matrix', 'Complex', 'BigNumber', 'Fraction'];
+export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    config,
+    typed,
+    isNegative,
+    unaryMinus,
+    matrix,
+    Complex,
+    BigNumber,
+    Fraction
+  } = _ref;
+
+  /**
+   * Calculate the cubic root of a value.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.cbrt(x)
+   *    math.cbrt(x, allRoots)
+   *
+   * Examples:
+   *
+   *    math.cbrt(27)                  // returns 3
+   *    math.cube(3)                   // returns 27
+   *    math.cbrt(-64)                 // returns -4
+   *    math.cbrt(math.unit('27 m^3')) // returns Unit 3 m
+   *    math.cbrt([27, 64, 125])       // returns [3, 4, 5]
+   *
+   *    const x = math.complex('8i')
+   *    math.cbrt(x)                   // returns Complex 1.7320508075689 + i
+   *    math.cbrt(x, true)             // returns Matrix [
+   *                                    //    1.7320508075689 + i
+   *                                    //   -1.7320508075689 + i
+   *                                    //   -2i
+   *                                    // ]
+   *
+   * See also:
+   *
+   *    square, sqrt, cube
+   *
+   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x
+   *            Value for which to calculate the cubic root.
+   * @param {boolean} [allRoots]  Optional, false by default. Only applicable
+   *            when `x` is a number or complex number. If true, all complex
+   *            roots are returned, if false (default) the principal root is
+   *            returned.
+   * @return {number | BigNumber | Complex | Unit | Array | Matrix}
+   *            Returns the cubic root of `x`
+   */
+  return typed(name, {
+    number: cbrtNumber,
+    // note: signature 'number, boolean' is also supported,
+    //       created by typed as it knows how to convert number to Complex
+    Complex: _cbrtComplex,
+    'Complex, boolean': _cbrtComplex,
+    BigNumber: function BigNumber(x) {
+      return x.cbrt();
+    },
+    Unit: _cbrtUnit,
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since cbrt(0) = 0
+      return deepMap(x, this, true);
+    }
+  });
+  /**
+   * Calculate the cubic root for a complex number
+   * @param {Complex} x
+   * @param {boolean} [allRoots]   If true, the function will return an array
+   *                               with all three roots. If false or undefined,
+   *                               the principal root is returned.
+   * @returns {Complex | Array.<Complex> | Matrix.<Complex>} Returns the cubic root(s) of x
+   * @private
+   */
+
+  function _cbrtComplex(x, allRoots) {
+    // https://www.wikiwand.com/en/Cube_root#/Complex_numbers
+    var arg3 = x.arg() / 3;
+    var abs = x.abs(); // principal root:
+
+    var principal = new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3).exp());
+
+    if (allRoots) {
+      var all = [principal, new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3 + Math.PI * 2 / 3).exp()), new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3 - Math.PI * 2 / 3).exp())];
+      return config.matrix === 'Array' ? all : matrix(all);
+    } else {
+      return principal;
+    }
+  }
+  /**
+   * Calculate the cubic root for a Unit
+   * @param {Unit} x
+   * @return {Unit} Returns the cubic root of x
+   * @private
+   */
+
+
+  function _cbrtUnit(x) {
+    if (x.value && isComplex(x.value)) {
+      var result = x.clone();
+      result.value = 1.0;
+      result = result.pow(1.0 / 3); // Compute the units
+
+      result.value = _cbrtComplex(x.value); // Compute the value
+
+      return result;
+    } else {
+      var negate = isNegative(x.value);
+
+      if (negate) {
+        x.value = unaryMinus(x.value);
+      } // TODO: create a helper function for this
+
+
+      var third;
+
+      if (isBigNumber(x.value)) {
+        third = new BigNumber(1).div(3);
+      } else if (isFraction(x.value)) {
+        third = new Fraction(1, 3);
+      } else {
+        third = 1 / 3;
+      }
+
+      var _result = x.pow(third);
+
+      if (negate) {
+        _result.value = unaryMinus(_result.value);
+      }
+
+      return _result;
+    }
+  }
+});

package/dist/node_modules/mathjs/lib/esm/function/arithmetic/ceil.js

@@ -0,0 +1,164 @@
+import Decimal from 'decimal.js';
+import { factory } from '../../utils/factory.js';
+import { deepMap } from '../../utils/collection.js';
+import { nearlyEqual } from '../../utils/number.js';
+import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
+import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
+import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
+import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+var name = 'ceil';
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.ceil(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
+  var {
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  var algorithm11 = createAlgorithm11({
+    typed,
+    equalScalar
+  });
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
+  var algorithm14 = createAlgorithm14({
+    typed
+  });
+  var ceilNumber = createCeilNumber({
+    typed,
+    config,
+    round
+  });
+  /**
+   * Round a value towards plus infinity
+   * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.ceil(x)
+   *    math.ceil(x, n)
+   *
+   * Examples:
+   *
+   *    math.ceil(3.2)               // returns number 4
+   *    math.ceil(3.8)               // returns number 4
+   *    math.ceil(-4.2)              // returns number -4
+   *    math.ceil(-4.7)              // returns number -4
+   *
+   *    math.ceil(3.212, 2)          // returns number 3.22
+   *    math.ceil(3.288, 2)          // returns number 3.29
+   *    math.ceil(-4.212, 2)         // returns number -4.21
+   *    math.ceil(-4.782, 2)         // returns number -4.78
+   *
+   *    const c = math.complex(3.24, -2.71)
+   *    math.ceil(c)                 // returns Complex 4 - 2i
+   *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
+   *
+   *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
+   *    math.ceil([3.21, 3.82, -4.71], 1)  // returns Array [3.3, 3.9, -4.7]
+   *
+   * See also:
+   *
+   *    floor, fix, round
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
+   */
+
+  return typed('ceil', {
+    number: ceilNumber.signatures.number,
+    'number,number': ceilNumber.signatures['number,number'],
+    Complex: function Complex(x) {
+      return x.ceil();
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.ceil(n);
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
+    BigNumber: function BigNumber(x) {
+      if (bigNearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return x.ceil();
+      }
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_CEIL);
+      }
+    },
+    Fraction: function Fraction(x) {
+      return x.ceil();
+    },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.ceil(n);
+    },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return deepMap(x, this, true);
+    },
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return deepMap(x, i => this(i, n), true);
+    },
+    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
+      return algorithm11(x, y, this, false);
+    },
+    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
+      return algorithm14(x, y, this, false);
+    },
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/esm/function/arithmetic/cube.js

@@ -0,0 +1,54 @@
+import { factory } from '../../utils/factory.js';
+import { deepMap } from '../../utils/collection.js';
+import { cubeNumber } from '../../plain/number/index.js';
+var name = 'cube';
+var dependencies = ['typed'];
+export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+
+  /**
+   * Compute the cube of a value, `x * x * x`.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.cube(x)
+   *
+   * Examples:
+   *
+   *    math.cube(2)            // returns number 8
+   *    math.pow(2, 3)          // returns number 8
+   *    math.cube(4)            // returns number 64
+   *    4 * 4 * 4               // returns number 64
+   *
+   *    math.cube([1, 2, 3, 4]) // returns Array [1, 8, 27, 64]
+   *
+   * See also:
+   *
+   *    multiply, square, pow, cbrt
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} x  Number for which to calculate the cube
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} Cube of x
+   */
+  return typed(name, {
+    number: cubeNumber,
+    Complex: function Complex(x) {
+      return x.mul(x).mul(x); // Is faster than pow(x, 3)
+    },
+    BigNumber: function BigNumber(x) {
+      return x.times(x).times(x);
+    },
+    Fraction: function Fraction(x) {
+      return x.pow(3); // Is faster than mul()mul()mul()
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      // deep map collection, skip zeros since cube(0) = 0
+      return deepMap(x, this, true);
+    },
+    Unit: function Unit(x) {
+      return x.pow(3);
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/esm/function/arithmetic/divide.js

@@ -0,0 +1,78 @@
+import { factory } from '../../utils/factory.js';
+import { extend } from '../../utils/object.js';
+import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
+import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+var name = 'divide';
+var dependencies = ['typed', 'matrix', 'multiply', 'equalScalar', 'divideScalar', 'inv'];
+export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    multiply,
+    equalScalar,
+    divideScalar,
+    inv
+  } = _ref;
+  var algorithm11 = createAlgorithm11({
+    typed,
+    equalScalar
+  });
+  var algorithm14 = createAlgorithm14({
+    typed
+  });
+  /**
+   * Divide two values, `x / y`.
+   * To divide matrices, `x` is multiplied with the inverse of `y`: `x * inv(y)`.
+   *
+   * Syntax:
+   *
+   *    math.divide(x, y)
+   *
+   * Examples:
+   *
+   *    math.divide(2, 3)            // returns number 0.6666666666666666
+   *
+   *    const a = math.complex(5, 14)
+   *    const b = math.complex(4, 1)
+   *    math.divide(a, b)            // returns Complex 2 + 3i
+   *
+   *    const c = [[7, -6], [13, -4]]
+   *    const d = [[1, 2], [4, 3]]
+   *    math.divide(c, d)            // returns Array [[-9, 4], [-11, 6]]
+   *
+   *    const e = math.unit('18 km')
+   *    math.divide(e, 4.5)          // returns Unit 4 km
+   *
+   * See also:
+   *
+   *    multiply
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x   Numerator
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} y          Denominator
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
+   */
+
+  return typed('divide', extend({
+    // we extend the signatures of divideScalar with signatures dealing with matrices
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(x, y) {
+      // TODO: implement matrix right division using pseudo inverse
+      // https://www.mathworks.nl/help/matlab/ref/mrdivide.html
+      // https://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html
+      // https://stackoverflow.com/questions/12263932/how-does-gnu-octave-matrix-division-work-getting-unexpected-behaviour
+      return multiply(x, inv(y));
+    },
+    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+      return algorithm14(x, y, divideScalar, false);
+    },
+    'SparseMatrix, any': function SparseMatrixAny(x, y) {
+      return algorithm11(x, y, divideScalar, false);
+    },
+    'Array, any': function ArrayAny(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(x), y, divideScalar, false).valueOf();
+    },
+    'any, Array | Matrix': function anyArrayMatrix(x, y) {
+      return multiply(x, inv(y));
+    }
+  }, divideScalar.signatures));
+});

package/dist/node_modules/mathjs/lib/esm/function/arithmetic/divideScalar.js

@@ -0,0 +1,55 @@
+import { factory } from '../../utils/factory.js';
+import { typeOf } from '../../utils/is.js';
+var name = 'divideScalar';
+var dependencies = ['typed', 'numeric'];
+export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    numeric
+  } = _ref;
+
+  /**
+   * Divide two scalar values, `x / y`.
+   * This function is meant for internal use: it is used by the public functions
+   * `divide` and `inv`.
+   *
+   * This function does not support collections (Array or Matrix).
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x   Numerator
+   * @param  {number | BigNumber | Fraction | Complex} y          Denominator
+   * @return {number | BigNumber | Fraction | Complex | Unit}     Quotient, `x / y`
+   * @private
+   */
+  return typed(name, {
+    'number, number': function numberNumber(x, y) {
+      return x / y;
+    },
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.div(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return x.div(y);
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return x.div(y);
+    },
+    'Unit, number | Fraction | BigNumber': function UnitNumberFractionBigNumber(x, y) {
+      var res = x.clone(); // TODO: move the divide function to Unit.js, it uses internals of Unit
+
+      var one = numeric(1, typeOf(y));
+      res.value = this(res.value === null ? res._normalize(one) : res.value, y);
+      return res;
+    },
+    'number | Fraction | BigNumber, Unit': function numberFractionBigNumberUnit(x, y) {
+      var res = y.clone();
+      res = res.pow(-1); // TODO: move the divide function to Unit.js, it uses internals of Unit
+
+      var one = numeric(1, typeOf(x));
+      res.value = this(x, y.value === null ? y._normalize(one) : y.value);
+      return res;
+    },
+    'Unit, Unit': function UnitUnit(x, y) {
+      return x.divide(y);
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/esm/function/arithmetic/dotDivide.js

@@ -0,0 +1,118 @@
+import { factory } from '../../utils/factory.js';
+import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
+import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
+import { createAlgorithm07 } from '../../type/matrix/utils/algorithm07.js';
+import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
+import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
+import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
+import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+var name = 'dotDivide';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix'];
+export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    equalScalar,
+    divideScalar,
+    DenseMatrix
+  } = _ref;
+  var algorithm02 = createAlgorithm02({
+    typed,
+    equalScalar
+  });
+  var algorithm03 = createAlgorithm03({
+    typed
+  });
+  var algorithm07 = createAlgorithm07({
+    typed,
+    DenseMatrix
+  });
+  var algorithm11 = createAlgorithm11({
+    typed,
+    equalScalar
+  });
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
+  var algorithm13 = createAlgorithm13({
+    typed
+  });
+  var algorithm14 = createAlgorithm14({
+    typed
+  });
+  /**
+   * Divide two matrices element wise. The function accepts both matrices and
+   * scalar values.
+   *
+   * Syntax:
+   *
+   *    math.dotDivide(x, y)
+   *
+   * Examples:
+   *
+   *    math.dotDivide(2, 4)   // returns 0.5
+   *
+   *    a = [[9, 5], [6, 1]]
+   *    b = [[3, 2], [5, 2]]
+   *
+   *    math.dotDivide(a, b)   // returns [[3, 2.5], [1.2, 0.5]]
+   *    math.divide(a, b)      // returns [[1.75, 0.75], [-1.75, 2.25]]
+   *
+   * See also:
+   *
+   *    divide, multiply, dotMultiply
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x Numerator
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Denominator
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Quotient, `x ./ y`
+   */
+
+  return typed(name, {
+    'any, any': divideScalar,
+    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
+      return algorithm07(x, y, divideScalar, false);
+    },
+    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
+      return algorithm02(y, x, divideScalar, true);
+    },
+    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
+      return algorithm03(x, y, divideScalar, false);
+    },
+    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
+      return algorithm13(x, y, divideScalar);
+    },
+    '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));
+    },
+    'SparseMatrix, any': function SparseMatrixAny(x, y) {
+      return algorithm11(x, y, divideScalar, false);
+    },
+    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+      return algorithm14(x, y, divideScalar, false);
+    },
+    'any, SparseMatrix': function anySparseMatrix(x, y) {
+      return algorithm12(y, x, divideScalar, true);
+    },
+    'any, DenseMatrix': function anyDenseMatrix(x, y) {
+      return algorithm14(y, x, divideScalar, true);
+    },
+    'Array, any': function ArrayAny(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(x), y, divideScalar, false).valueOf();
+    },
+    'any, Array': function anyArray(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(y), x, divideScalar, true).valueOf();
+    }
+  });
+});