mathjs-min 11.7.2

package/lib/cjs/function/trigonometry/sec.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSec = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var _trigUnit = require("./trigUnit.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;
+  var trigUnit = (0, _trigUnit.createTrigUnit)({
+    typed: typed
+  });
+
+  /**
+   * Calculate the secant of a value, defined as `sec(x) = 1/cos(x)`.
+   *
+   * To avoid confusion with the matrix secant, this function does not
+   * apply to matrices.
+   *
+   * 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 | BigNumber | Complex | Unit} x  Function input
+   * @return {number | BigNumber | Complex} 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());
+    }
+  }, trigUnit);
+});
+exports.createSec = createSec;

package/lib/cjs/function/trigonometry/sech.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSech = void 0;
+var _factory = require("../../utils/factory.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)`.
+   *
+   * To avoid confusion with the matrix hyperbolic secant, this function does
+   * not apply to matrices.
+   *
+   * 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 | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} 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());
+    }
+  });
+});
+exports.createSech = createSech;

package/lib/cjs/function/trigonometry/sin.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSin = void 0;
+var _factory = require("../../utils/factory.js");
+var _trigUnit = require("./trigUnit.js");
+var name = 'sin';
+var dependencies = ['typed'];
+var createSin = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  var trigUnit = (0, _trigUnit.createTrigUnit)({
+    typed: typed
+  });
+
+  /**
+   * Calculate the sine of a value.
+   *
+   * To avoid confusion with the matrix sine, this function does not apply
+   * to matrices.
+   *
+   * 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} x  Function input
+   * @return {number | BigNumber | Complex} Sine of x
+   */
+  return typed(name, {
+    number: Math.sin,
+    'Complex | BigNumber': function ComplexBigNumber(x) {
+      return x.sin();
+    }
+  }, trigUnit);
+});
+exports.createSin = createSin;

package/lib/cjs/function/trigonometry/sinh.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSinh = void 0;
+var _factory = require("../../utils/factory.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))`.
+   *
+   * To avoid confusion with the matrix hyperbolic sine, this function does
+   * not apply to matrices.
+   *
+   * Syntax:
+   *
+   *    math.sinh(x)
+   *
+   * Examples:
+   *
+   *    math.sinh(0.5)       // returns number 0.5210953054937474
+   *
+   * See also:
+   *
+   *    cosh, tanh
+   *
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic sine of x
+   */
+  return typed(name, {
+    number: _index.sinhNumber,
+    'Complex | BigNumber': function ComplexBigNumber(x) {
+      return x.sinh();
+    }
+  });
+});
+exports.createSinh = createSinh;

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTan = void 0;
+var _factory = require("../../utils/factory.js");
+var _trigUnit = require("./trigUnit.js");
+var name = 'tan';
+var dependencies = ['typed'];
+var createTan = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  var trigUnit = (0, _trigUnit.createTrigUnit)({
+    typed: 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': function ComplexBigNumber(x) {
+      return x.tan();
+    }
+  }, trigUnit);
+});
+exports.createTan = createTan;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTanh = void 0;
+var _factory = require("../../utils/factory.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)`.
+   *
+   * 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: _number.tanh,
+    'Complex | BigNumber': function ComplexBigNumber(x) {
+      return x.tanh();
+    }
+  });
+});
+exports.createTanh = createTanh;

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTrigUnit = void 0;
+var _factory = require("../../utils/factory.js");
+var createTrigUnit = /* #__PURE__ */(0, _factory.factory)('trigUnit', ['typed'], function (_ref) {
+  var typed = _ref.typed;
+  return {
+    Unit: typed.referToSelf(function (self) {
+      return function (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);
+      };
+    })
+  };
+});
+exports.createTrigUnit = createTrigUnit;

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

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTo = void 0;
+var _factory = require("../../utils/factory.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
+var name = 'to';
+var dependencies = ['typed', 'matrix', 'concat'];
+var createTo = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    concat = _ref.concat;
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: 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': function UnitUnitString(x, unit) {
+      return x.to(unit);
+    }
+  }, matrixAlgorithmSuite({
+    Ds: true
+  }));
+});
+exports.createTo = createTo;

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

@@ -0,0 +1,35 @@
+"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/lib/cjs/function/utils/hasNumericValue.js

@@ -0,0 +1,55 @@
+"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(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": function boolean() {
+      return true;
+    },
+    string: function string(x) {
+      return x.trim().length > 0 && !isNaN(Number(x));
+    },
+    any: function any(x) {
+      return isNumeric(x);
+    }
+  });
+});
+exports.createHasNumericValue = createHasNumericValue;

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

@@ -0,0 +1,60 @@
+"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': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
+  });
+});
+exports.createIsInteger = createIsInteger;

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

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsNaN = void 0;
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'isNaN';
+var dependencies = ['typed'];
+var createIsNaN = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * 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: _index.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 (0, _collection.deepMap)(x, Number.isNaN);
+    }
+  });
+});
+exports.createIsNaN = createIsNaN;

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

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIsNegative = void 0;
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'isNegative';
+var dependencies = ['typed'];
+var createIsNegative = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * 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: _index.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(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
+  });
+});
+exports.createIsNegative = createIsNegative;