mathjs-min 11.7.2

package/lib/esm/function/trigonometry/tan.js

@@ -0,0 +1,41 @@
+import { factory } from '../../utils/factory.js';
+import { createTrigUnit } from './trigUnit.js';
+var name = 'tan';
+var dependencies = ['typed'];
+export var createTan = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  var trigUnit = createTrigUnit({
+    typed
+  });
+
+  /**
+   * Calculate the tangent of a value. `tan(x)` is equal to `sin(x) / cos(x)`.
+   *
+   * To avoid confusion with the matrix tangent, this function does not apply
+   * to matrices.
+   *
+   * 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} x  Function input
+   * @return {number | BigNumber | Complex} Tangent of x
+   */
+  return typed(name, {
+    number: Math.tan,
+    'Complex | BigNumber': x => x.tan()
+  }, trigUnit);
+});

package/lib/esm/function/trigonometry/tanh.js

@@ -0,0 +1,38 @@
+import { factory } from '../../utils/factory.js';
+import { tanh as _tanh } from '../../utils/number.js';
+var name = 'tanh';
+var dependencies = ['typed'];
+export var createTanh = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Calculate the hyperbolic tangent of a value,
+   * defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
+   *
+   * To avoid confusion with matrix hyperbolic tangent, this function does
+   * not apply to matrices.
+   *
+   * 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} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic tangent of x
+   */
+  return typed('tanh', {
+    number: _tanh,
+    'Complex | BigNumber': x => x.tanh()
+  });
+});

package/lib/esm/function/trigonometry/trigUnit.js

@@ -0,0 +1,14 @@
+import { factory } from '../../utils/factory.js';
+export var createTrigUnit = /* #__PURE__ */factory('trigUnit', ['typed'], _ref => {
+  var {
+    typed
+  } = _ref;
+  return {
+    Unit: typed.referToSelf(self => x => {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function cot is no angle');
+      }
+      return typed.find(self, x.valueType())(x.value);
+    })
+  };
+});

package/lib/esm/function/unit/to.js

@@ -0,0 +1,46 @@
+import { factory } from '../../utils/factory.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+var name = 'to';
+var dependencies = ['typed', 'matrix', 'concat'];
+export var createTo = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    concat
+  } = _ref;
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+
+  /**
+   * 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('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': (x, unit) => x.to(unit)
+  }, matrixAlgorithmSuite({
+    Ds: true
+  }));
+});

package/lib/esm/function/utils/clone.js

@@ -0,0 +1,30 @@
+import { clone as objectClone } from '../../utils/object.js';
+import { factory } from '../../utils/factory.js';
+var name = 'clone';
+var dependencies = ['typed'];
+export var createClone = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * 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: objectClone
+  });
+});

package/lib/esm/function/utils/hasNumericValue.js

@@ -0,0 +1,48 @@
+import { factory } from '../../utils/factory.js';
+var name = 'hasNumericValue';
+var dependencies = ['typed', 'isNumeric'];
+export var createHasNumericValue = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isNumeric
+  } = _ref;
+  /**
+   * 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(false)                 // returns true
+   *    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, {
+    boolean: () => true,
+    string: function string(x) {
+      return x.trim().length > 0 && !isNaN(Number(x));
+    },
+    any: function any(x) {
+      return isNumeric(x);
+    }
+  });
+});

package/lib/esm/function/utils/isInteger.js

@@ -0,0 +1,51 @@
+import { deepMap } from '../../utils/collection.js';
+import { isInteger as isIntegerNumber } from '../../utils/number.js';
+import { factory } from '../../utils/factory.js';
+var name = 'isInteger';
+var dependencies = ['typed'];
+export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * 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: isIntegerNumber,
+    // 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': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/function/utils/isNaN.js

@@ -0,0 +1,57 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { isNaNNumber } from '../../plain/number/index.js';
+var name = 'isNaN';
+var dependencies = ['typed'];
+export var createIsNaN = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is NaN (not a number).
+   * The function supports types `number`, `BigNumber`, `Fraction`, `Unit` and `Complex`.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isNaN(x)
+   *
+   * Examples:
+   *
+   *    math.isNaN(3)                     // returns false
+   *    math.isNaN(NaN)                   // returns true
+   *    math.isNaN(0)                     // returns false
+   *    math.isNaN(math.bignumber(NaN))   // returns true
+   *    math.isNaN(math.bignumber(0))     // returns false
+   *    math.isNaN(math.fraction(-2, 5))  // returns false
+   *    math.isNaN('-2')                  // returns false
+   *    math.isNaN([2, 0, -3, NaN])       // returns [false, false, false, true]
+   *
+   * See also:
+   *
+   *    isNumeric, isNegative, isPositive, isZero, isInteger
+   *
+   * @param {number | BigNumber | Fraction | Unit | Array | Matrix} x  Value to be tested
+   * @return {boolean}  Returns true when `x` is NaN.
+   *                    Throws an error in case of an unknown data type.
+   */
+  return typed(name, {
+    number: isNaNNumber,
+    BigNumber: function BigNumber(x) {
+      return x.isNaN();
+    },
+    Fraction: function Fraction(x) {
+      return false;
+    },
+    Complex: function Complex(x) {
+      return x.isNaN();
+    },
+    Unit: function Unit(x) {
+      return Number.isNaN(x.value);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return deepMap(x, Number.isNaN);
+    }
+  });
+});

package/lib/esm/function/utils/isNegative.js

@@ -0,0 +1,51 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { isNegativeNumber } from '../../plain/number/index.js';
+var name = 'isNegative';
+var dependencies = ['typed'];
+export var createIsNegative = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is negative: smaller than zero.
+   * The function supports types `number`, `BigNumber`, `Fraction`, and `Unit`.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isNegative(x)
+   *
+   * Examples:
+   *
+   *    math.isNegative(3)                     // returns false
+   *    math.isNegative(-2)                    // returns true
+   *    math.isNegative(0)                     // returns false
+   *    math.isNegative(-0)                    // returns false
+   *    math.isNegative(math.bignumber(2))     // returns false
+   *    math.isNegative(math.fraction(-2, 5))  // returns true
+   *    math.isNegative('-2')                  // returns true
+   *    math.isNegative([2, 0, -3])            // returns [false, false, true]
+   *
+   * See also:
+   *
+   *    isNumeric, isPositive, isZero, isInteger
+   *
+   * @param {number | BigNumber | Fraction | Unit | Array | Matrix} x  Value to be tested
+   * @return {boolean}  Returns true when `x` is larger than zero.
+   *                    Throws an error in case of an unknown data type.
+   */
+  return typed(name, {
+    number: isNegativeNumber,
+    BigNumber: function BigNumber(x) {
+      return x.isNeg() && !x.isZero() && !x.isNaN();
+    },
+    Fraction: function Fraction(x) {
+      return x.s < 0; // It's enough to decide on the sign
+    },
+
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/function/utils/isNumeric.js

@@ -0,0 +1,43 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+var name = 'isNumeric';
+var dependencies = ['typed'];
+export var createIsNumeric = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is an numeric value.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isNumeric(x)
+   *
+   * Examples:
+   *
+   *    math.isNumeric(2)                     // returns true
+   *    math.isNumeric('2')                   // returns false
+   *    math.hasNumericValue('2')             // returns true
+   *    math.isNumeric(0)                     // returns true
+   *    math.isNumeric(math.bignumber(500))   // returns true
+   *    math.isNumeric(math.fraction(4))      // returns true
+   *    math.isNumeric(math.complex('2-4i'))  // returns false
+   *    math.isNumeric([2.3, 'foo', false])   // returns [true, false, true]
+   *
+   * See also:
+   *
+   *    isZero, isPositive, isNegative, isInteger, hasNumericValue
+   *
+   * @param {*} x       Value to be tested
+   * @return {boolean}  Returns true when `x` is a `number`, `BigNumber`,
+   *                    `Fraction`, or `boolean`. Returns false for other types.
+   *                    Throws an error in case of unknown types.
+   */
+  return typed(name, {
+    'number | BigNumber | Fraction | boolean': () => true,
+    'Complex | Unit | string | null | undefined | Node': () => false,
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/function/utils/isPositive.js

@@ -0,0 +1,52 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { isPositiveNumber } from '../../plain/number/index.js';
+var name = 'isPositive';
+var dependencies = ['typed'];
+export var createIsPositive = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is positive: larger than zero.
+   * The function supports types `number`, `BigNumber`, `Fraction`, and `Unit`.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isPositive(x)
+   *
+   * Examples:
+   *
+   *    math.isPositive(3)                     // returns true
+   *    math.isPositive(-2)                    // returns false
+   *    math.isPositive(0)                     // returns false
+   *    math.isPositive(-0)                    // returns false
+   *    math.isPositive(0.5)                   // returns true
+   *    math.isPositive(math.bignumber(2))     // returns true
+   *    math.isPositive(math.fraction(-2, 5))  // returns false
+   *    math.isPositive(math.fraction(1, 3))   // returns true
+   *    math.isPositive('2')                   // returns true
+   *    math.isPositive([2, 0, -3])            // returns [true, false, false]
+   *
+   * See also:
+   *
+   *    isNumeric, isZero, isNegative, isInteger
+   *
+   * @param {number | BigNumber | Fraction | Unit | Array | Matrix} x  Value to be tested
+   * @return {boolean}  Returns true when `x` is larger than zero.
+   *                    Throws an error in case of an unknown data type.
+   */
+  return typed(name, {
+    number: isPositiveNumber,
+    BigNumber: function BigNumber(x) {
+      return !x.isNeg() && !x.isZero() && !x.isNaN();
+    },
+    Fraction: function Fraction(x) {
+      return x.s > 0 && x.n > 0;
+    },
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/function/utils/isPrime.js

@@ -0,0 +1,122 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+var name = 'isPrime';
+var dependencies = ['typed'];
+export var createIsPrime = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is prime: has no divisors other than itself and one.
+   * The function supports type `number`, `bignumber`.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isPrime(x)
+   *
+   * Examples:
+   *
+   *    math.isPrime(3)                     // returns true
+   *    math.isPrime(-2)                    // returns false
+   *    math.isPrime(0)                     // returns false
+   *    math.isPrime(-0)                    // returns false
+   *    math.isPrime(0.5)                   // returns false
+   *    math.isPrime('2')                   // returns true
+   *    math.isPrime([2, 17, 100])           // returns [true, true, false]
+   *
+   * See also:
+   *
+   *    isNumeric, isZero, isNegative, isInteger
+   *
+   * @param {number | BigNumber | Array | Matrix} x  Value to be tested
+   * @return {boolean}  Returns true when `x` is larger than zero.
+   *                    Throws an error in case of an unknown data type.
+   */
+  return typed(name, {
+    number: function number(x) {
+      if (x * 0 !== 0) {
+        return false;
+      }
+      if (x <= 3) {
+        return x > 1;
+      }
+      if (x % 2 === 0 || x % 3 === 0) {
+        return false;
+      }
+      for (var i = 5; i * i <= x; i += 6) {
+        if (x % i === 0 || x % (i + 2) === 0) {
+          return false;
+        }
+      }
+      return true;
+    },
+    BigNumber: function BigNumber(n) {
+      if (n.toNumber() * 0 !== 0) {
+        return false;
+      }
+      if (n.lte(3)) return n.gt(1);
+      if (n.mod(2).eq(0) || n.mod(3).eq(0)) return false;
+      if (n.lt(Math.pow(2, 32))) {
+        var x = n.toNumber();
+        for (var i = 5; i * i <= x; i += 6) {
+          if (x % i === 0 || x % (i + 2) === 0) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function modPow(base, exponent, modulus) {
+        // exponent can be huge, use non-recursive variant
+        var accumulator = 1;
+        while (!exponent.eq(0)) {
+          if (exponent.mod(2).eq(0)) {
+            exponent = exponent.div(2);
+            base = base.mul(base).mod(modulus);
+          } else {
+            exponent = exponent.sub(1);
+            accumulator = base.mul(accumulator).mod(modulus);
+          }
+        }
+        return accumulator;
+      }
+
+      // https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test#Deterministic_variants
+      var Decimal = n.constructor.clone({
+        precision: n.toFixed(0).length * 2
+      });
+      n = new Decimal(n);
+      var r = 0;
+      var d = n.sub(1);
+      while (d.mod(2).eq(0)) {
+        d = d.div(2);
+        r += 1;
+      }
+      var bases = null;
+      // https://en.wikipedia.org/wiki/Miller–Rabin_primality_test#Testing_against_small_sets_of_bases
+      if (n.lt('3317044064679887385961981')) {
+        bases = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41].filter(x => x < n);
+      } else {
+        var max = Math.min(n.toNumber() - 2, Math.floor(2 * Math.pow(n.toFixed(0).length * Math.log(10), 2)));
+        bases = [];
+        for (var _i = 2; _i <= max; _i += 1) {
+          bases.push(max);
+        }
+      }
+      for (var _i2 = 0; _i2 < bases.length; _i2 += 1) {
+        var a = bases[_i2];
+        var adn = modPow(n.sub(n).add(a), d, n);
+        if (!adn.eq(1)) {
+          for (var _i3 = 0, _x = adn; !_x.eq(n.sub(1)); _i3 += 1, _x = _x.mul(_x).mod(n)) {
+            if (_i3 === r - 1) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/function/utils/isZero.js

@@ -0,0 +1,57 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { isZeroNumber } from '../../plain/number/index.js';
+var name = 'isZero';
+var dependencies = ['typed'];
+export var createIsZero = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is zero.
+   * The function can check for zero for types `number`, `BigNumber`, `Fraction`,
+   * `Complex`, and `Unit`.
+   *
+   * The function is evaluated element-wise in case of Array or Matrix input.
+   *
+   * Syntax:
+   *
+   *     math.isZero(x)
+   *
+   * Examples:
+   *
+   *    math.isZero(0)                      // returns true
+   *    math.isZero(2)                      // returns false
+   *    math.isZero(0.5)                    // returns false
+   *    math.isZero(math.bignumber(0))      // returns true
+   *    math.isZero(math.fraction(0))       // returns true
+   *    math.isZero(math.fraction(1,3))     // returns false
+   *    math.isZero(math.complex('2 - 4i')) // returns false
+   *    math.isZero(math.complex('0i'))     // returns true
+   *    math.isZero('0')                    // returns true
+   *    math.isZero('2')                    // returns false
+   *    math.isZero([2, 0, -3])             // returns [false, true, false]
+   *
+   * See also:
+   *
+   *    isNumeric, isPositive, isNegative, isInteger
+   *
+   * @param {number | BigNumber | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean}  Returns true when `x` is zero.
+   *                    Throws an error in case of an unknown data type.
+   */
+  return typed(name, {
+    number: isZeroNumber,
+    BigNumber: function BigNumber(x) {
+      return x.isZero();
+    },
+    Complex: function Complex(x) {
+      return x.re === 0 && x.im === 0;
+    },
+    Fraction: function Fraction(x) {
+      return x.d === 1 && x.n === 0;
+    },
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});