mathjs-min 11.7.2

package/lib/esm/expression/embeddedDocs/function/trigonometry/coth.js

@@ -0,0 +1,8 @@
+export var cothDocs = {
+  name: 'coth',
+  category: 'Trigonometry',
+  syntax: ['coth(x)'],
+  description: 'Compute the hyperbolic cotangent of x in radians.',
+  examples: ['coth(2)', '1 / tanh(2)'],
+  seealso: ['sech', 'csch', 'tanh']
+};

package/lib/esm/expression/embeddedDocs/function/trigonometry/csc.js

@@ -0,0 +1,8 @@
+export var cscDocs = {
+  name: 'csc',
+  category: 'Trigonometry',
+  syntax: ['csc(x)'],
+  description: 'Compute the cosecant of x in radians. Defined as 1/sin(x)',
+  examples: ['csc(2)', '1 / sin(2)'],
+  seealso: ['sec', 'cot', 'sin']
+};

package/lib/esm/expression/embeddedDocs/function/trigonometry/csch.js

@@ -0,0 +1,8 @@
+export var cschDocs = {
+  name: 'csch',
+  category: 'Trigonometry',
+  syntax: ['csch(x)'],
+  description: 'Compute the hyperbolic cosecant of x in radians. Defined as 1/sinh(x)',
+  examples: ['csch(2)', '1 / sinh(2)'],
+  seealso: ['sech', 'coth', 'sinh']
+};

package/lib/esm/expression/embeddedDocs/function/trigonometry/sec.js

@@ -0,0 +1,8 @@
+export var secDocs = {
+  name: 'sec',
+  category: 'Trigonometry',
+  syntax: ['sec(x)'],
+  description: 'Compute the secant of x in radians. Defined as 1/cos(x)',
+  examples: ['sec(2)', '1 / cos(2)'],
+  seealso: ['cot', 'csc', 'cos']
+};

package/lib/esm/expression/embeddedDocs/function/trigonometry/sech.js

@@ -0,0 +1,8 @@
+export var sechDocs = {
+  name: 'sech',
+  category: 'Trigonometry',
+  syntax: ['sech(x)'],
+  description: 'Compute the hyperbolic secant of x in radians. Defined as 1/cosh(x)',
+  examples: ['sech(2)', '1 / cosh(2)'],
+  seealso: ['coth', 'csch', 'cosh']
+};

package/lib/esm/expression/embeddedDocs/function/trigonometry/sin.js

@@ -0,0 +1,8 @@
+export var sinDocs = {
+  name: 'sin',
+  category: 'Trigonometry',
+  syntax: ['sin(x)'],
+  description: 'Compute the sine of x in radians.',
+  examples: ['sin(2)', 'sin(pi / 4) ^ 2', 'sin(90 deg)', 'sin(30 deg)', 'sin(0.2)^2 + cos(0.2)^2'],
+  seealso: ['asin', 'cos', 'tan']
+};

package/lib/esm/expression/embeddedDocs/function/trigonometry/sinh.js

@@ -0,0 +1,8 @@
+export var sinhDocs = {
+  name: 'sinh',
+  category: 'Trigonometry',
+  syntax: ['sinh(x)'],
+  description: 'Compute the hyperbolic sine of x in radians.',
+  examples: ['sinh(0.5)'],
+  seealso: ['cosh', 'tanh']
+};

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

@@ -0,0 +1,8 @@
+export var tanDocs = {
+  name: 'tan',
+  category: 'Trigonometry',
+  syntax: ['tan(x)'],
+  description: 'Compute the tangent of x in radians.',
+  examples: ['tan(0.5)', 'sin(0.5) / cos(0.5)', 'tan(pi / 4)', 'tan(45 deg)'],
+  seealso: ['atan', 'sin', 'cos']
+};

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

@@ -0,0 +1,8 @@
+export var tanhDocs = {
+  name: 'tanh',
+  category: 'Trigonometry',
+  syntax: ['tanh(x)'],
+  description: 'Compute the hyperbolic tangent of x in radians.',
+  examples: ['tanh(0.5)', 'sinh(0.5) / cosh(0.5)'],
+  seealso: ['sinh', 'cosh']
+};

package/lib/esm/expression/embeddedDocs/function/units/to.js

@@ -0,0 +1,8 @@
+export var toDocs = {
+  name: 'to',
+  category: 'Units',
+  syntax: ['x to unit', 'to(x, unit)'],
+  description: 'Change the unit of a value.',
+  examples: ['5 inch to cm', '3.2kg to g', '16 bytes in bits'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/utils/bin.js

@@ -0,0 +1,8 @@
+export var binDocs = {
+  name: 'bin',
+  category: 'Utils',
+  syntax: ['bin(value)'],
+  description: 'Format a number as binary',
+  examples: ['bin(2)'],
+  seealso: ['oct', 'hex']
+};

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

@@ -0,0 +1,8 @@
+export var cloneDocs = {
+  name: 'clone',
+  category: 'Utils',
+  syntax: ['clone(x)'],
+  description: 'Clone a variable. Creates a copy of primitive variables,and a deep copy of matrices',
+  examples: ['clone(3.5)', 'clone(2 - 4i)', 'clone(45 deg)', 'clone([1, 2; 3, 4])', 'clone("hello world")'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/utils/format.js

@@ -0,0 +1,8 @@
+export var formatDocs = {
+  name: 'format',
+  category: 'Utils',
+  syntax: ['format(value)', 'format(value, precision)'],
+  description: 'Format a value of any type as string.',
+  examples: ['format(2.3)', 'format(3 - 4i)', 'format([])', 'format(pi, 3)'],
+  seealso: ['print']
+};

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

@@ -0,0 +1,8 @@
+export var hasNumericValueDocs = {
+  name: 'hasNumericValue',
+  category: 'Utils',
+  syntax: ['hasNumericValue(x)'],
+  description: 'Test whether a value is an numeric value. ' + 'In case of a string, true is returned if the string contains a numeric value.',
+  examples: ['hasNumericValue(2)', 'hasNumericValue("2")', 'isNumeric("2")', 'hasNumericValue(0)', 'hasNumericValue(bignumber(500))', 'hasNumericValue(fraction(0.125))', 'hasNumericValue(2 + 3i)', 'hasNumericValue([2.3, "foo", false])'],
+  seealso: ['isInteger', 'isZero', 'isNegative', 'isPositive', 'isNaN', 'isNumeric']
+};

package/lib/esm/expression/embeddedDocs/function/utils/hex.js

@@ -0,0 +1,8 @@
+export var hexDocs = {
+  name: 'hex',
+  category: 'Utils',
+  syntax: ['hex(value)'],
+  description: 'Format a number as hexadecimal',
+  examples: ['hex(240)'],
+  seealso: ['bin', 'oct']
+};

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

@@ -0,0 +1,8 @@
+export var isIntegerDocs = {
+  name: 'isInteger',
+  category: 'Utils',
+  syntax: ['isInteger(x)'],
+  description: 'Test whether a value is an integer number.',
+  examples: ['isInteger(2)', 'isInteger(3.5)', 'isInteger([3, 0.5, -2])'],
+  seealso: ['isNegative', 'isNumeric', 'isPositive', 'isZero']
+};

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

@@ -0,0 +1,8 @@
+export var isNaNDocs = {
+  name: 'isNaN',
+  category: 'Utils',
+  syntax: ['isNaN(x)'],
+  description: 'Test whether a value is NaN (not a number)',
+  examples: ['isNaN(2)', 'isNaN(0 / 0)', 'isNaN(NaN)', 'isNaN(Infinity)'],
+  seealso: ['isNegative', 'isNumeric', 'isPositive', 'isZero']
+};

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

@@ -0,0 +1,8 @@
+export var isNegativeDocs = {
+  name: 'isNegative',
+  category: 'Utils',
+  syntax: ['isNegative(x)'],
+  description: 'Test whether a value is negative: smaller than zero.',
+  examples: ['isNegative(2)', 'isNegative(0)', 'isNegative(-4)', 'isNegative([3, 0.5, -2])'],
+  seealso: ['isInteger', 'isNumeric', 'isPositive', 'isZero']
+};

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

@@ -0,0 +1,8 @@
+export var isNumericDocs = {
+  name: 'isNumeric',
+  category: 'Utils',
+  syntax: ['isNumeric(x)'],
+  description: 'Test whether a value is a numeric value. ' + 'Returns true when the input is a number, BigNumber, Fraction, or boolean.',
+  examples: ['isNumeric(2)', 'isNumeric("2")', 'hasNumericValue("2")', 'isNumeric(0)', 'isNumeric(bignumber(500))', 'isNumeric(fraction(0.125))', 'isNumeric(2 + 3i)', 'isNumeric([2.3, "foo", false])'],
+  seealso: ['isInteger', 'isZero', 'isNegative', 'isPositive', 'isNaN', 'hasNumericValue']
+};

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

@@ -0,0 +1,8 @@
+export var isPositiveDocs = {
+  name: 'isPositive',
+  category: 'Utils',
+  syntax: ['isPositive(x)'],
+  description: 'Test whether a value is positive: larger than zero.',
+  examples: ['isPositive(2)', 'isPositive(0)', 'isPositive(-4)', 'isPositive([3, 0.5, -2])'],
+  seealso: ['isInteger', 'isNumeric', 'isNegative', 'isZero']
+};

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

@@ -0,0 +1,8 @@
+export var isPrimeDocs = {
+  name: 'isPrime',
+  category: 'Utils',
+  syntax: ['isPrime(x)'],
+  description: 'Test whether a value is prime: has no divisors other than itself and one.',
+  examples: ['isPrime(3)', 'isPrime(-2)', 'isPrime([2, 17, 100])'],
+  seealso: ['isInteger', 'isNumeric', 'isNegative', 'isZero']
+};

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

@@ -0,0 +1,8 @@
+export var isZeroDocs = {
+  name: 'isZero',
+  category: 'Utils',
+  syntax: ['isZero(x)'],
+  description: 'Test whether a value is zero.',
+  examples: ['isZero(2)', 'isZero(0)', 'isZero(-4)', 'isZero([3, 0, -2, 0])'],
+  seealso: ['isInteger', 'isNumeric', 'isNegative', 'isPositive']
+};

package/lib/esm/expression/embeddedDocs/function/utils/numeric.js

@@ -0,0 +1,8 @@
+export var numericDocs = {
+  name: 'numeric',
+  category: 'Utils',
+  syntax: ['numeric(x)'],
+  description: 'Convert a numeric input to a specific numeric type: number, BigNumber, or Fraction.',
+  examples: ['numeric("4")', 'numeric("4", "number")', 'numeric("4", "BigNumber")', 'numeric("4", "Fraction)', 'numeric(4, "Fraction")', 'numeric(fraction(2, 5), "number)'],
+  seealso: ['number', 'fraction', 'bignumber', 'string', 'format']
+};

package/lib/esm/expression/embeddedDocs/function/utils/oct.js

@@ -0,0 +1,8 @@
+export var octDocs = {
+  name: 'oct',
+  category: 'Utils',
+  syntax: ['oct(value)'],
+  description: 'Format a number as octal',
+  examples: ['oct(56)'],
+  seealso: ['bin', 'hex']
+};

package/lib/esm/expression/embeddedDocs/function/utils/print.js

@@ -0,0 +1,8 @@
+export var printDocs = {
+  name: 'print',
+  category: 'Utils',
+  syntax: ['print(template, values)', 'print(template, values, precision)'],
+  description: 'Interpolate values into a string template.',
+  examples: ['print("Lucy is $age years old", {age: 5})', 'print("The value of pi is $pi", {pi: pi}, 3)', 'print("Hello, $user.name!", {user: {name: "John"}})', 'print("Values: $0, $1, $2", [6, 9, 4])'],
+  seealso: ['format']
+};

package/lib/esm/expression/embeddedDocs/function/utils/typeOf.js

@@ -0,0 +1,8 @@
+export var typeOfDocs = {
+  name: 'typeOf',
+  category: 'Utils',
+  syntax: ['typeOf(x)'],
+  description: 'Get the type of a variable.',
+  examples: ['typeOf(3.5)', 'typeOf(2 - 4i)', 'typeOf(45 deg)', 'typeOf("hello world")'],
+  seealso: ['getMatrixDataType']
+};

package/lib/esm/expression/function/compile.js

@@ -0,0 +1,54 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+var name = 'compile';
+var dependencies = ['typed', 'parse'];
+export var createCompile = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    parse
+  } = _ref;
+  /**
+   * Parse and compile an expression.
+   * Returns a an object with a function `evaluate([scope])` to evaluate the
+   * compiled expression.
+   *
+   * Syntax:
+   *
+   *     math.compile(expr)                       // returns one node
+   *     math.compile([expr1, expr2, expr3, ...]) // returns an array with nodes
+   *
+   * Examples:
+   *
+   *     const code1 = math.compile('sqrt(3^2 + 4^2)')
+   *     code1.evaluate() // 5
+   *
+   *     let scope = {a: 3, b: 4}
+   *     const code2 = math.compile('a * b') // 12
+   *     code2.evaluate(scope) // 12
+   *     scope.a = 5
+   *     code2.evaluate(scope) // 20
+   *
+   *     const nodes = math.compile(['a = 3', 'b = 4', 'a * b'])
+   *     nodes[2].evaluate() // 12
+   *
+   * See also:
+   *
+   *    parse, evaluate
+   *
+   * @param {string | string[] | Array | Matrix} expr
+   *            The expression to be compiled
+   * @return {{evaluate: Function} | Array.<{evaluate: Function}>} code
+   *            An object with the compiled expression
+   * @throws {Error}
+   */
+  return typed(name, {
+    string: function string(expr) {
+      return parse(expr).compile();
+    },
+    'Array | Matrix': function ArrayMatrix(expr) {
+      return deepMap(expr, function (entry) {
+        return parse(entry).compile();
+      });
+    }
+  });
+});

package/lib/esm/expression/function/evaluate.js

@@ -0,0 +1,63 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { createEmptyMap } from '../../utils/map.js';
+var name = 'evaluate';
+var dependencies = ['typed', 'parse'];
+export var createEvaluate = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    parse
+  } = _ref;
+  /**
+   * Evaluate an expression.
+   *
+   * Note the evaluating arbitrary expressions may involve security risks,
+   * see [https://mathjs.org/docs/expressions/security.html](https://mathjs.org/docs/expressions/security.html) for more information.
+   *
+   * Syntax:
+   *
+   *     math.evaluate(expr)
+   *     math.evaluate(expr, scope)
+   *     math.evaluate([expr1, expr2, expr3, ...])
+   *     math.evaluate([expr1, expr2, expr3, ...], scope)
+   *
+   * Example:
+   *
+   *     math.evaluate('(2+3)/4')                // 1.25
+   *     math.evaluate('sqrt(3^2 + 4^2)')        // 5
+   *     math.evaluate('sqrt(-4)')               // 2i
+   *     math.evaluate(['a=3', 'b=4', 'a*b'])    // [3, 4, 12]
+   *
+   *     let scope = {a:3, b:4}
+   *     math.evaluate('a * b', scope)           // 12
+   *
+   * See also:
+   *
+   *    parse, compile
+   *
+   * @param {string | string[] | Matrix} expr   The expression to be evaluated
+   * @param {Object} [scope]                    Scope to read/write variables
+   * @return {*} The result of the expression
+   * @throws {Error}
+   */
+  return typed(name, {
+    string: function string(expr) {
+      var scope = createEmptyMap();
+      return parse(expr).compile().evaluate(scope);
+    },
+    'string, Map | Object': function stringMapObject(expr, scope) {
+      return parse(expr).compile().evaluate(scope);
+    },
+    'Array | Matrix': function ArrayMatrix(expr) {
+      var scope = createEmptyMap();
+      return deepMap(expr, function (entry) {
+        return parse(entry).compile().evaluate(scope);
+      });
+    },
+    'Array | Matrix, Map | Object': function ArrayMatrixMapObject(expr, scope) {
+      return deepMap(expr, function (entry) {
+        return parse(entry).compile().evaluate(scope);
+      });
+    }
+  });
+});

package/lib/esm/expression/function/help.js

@@ -0,0 +1,67 @@
+import { factory } from '../../utils/factory.js';
+import { getSafeProperty } from '../../utils/customs.js';
+import { embeddedDocs } from '../embeddedDocs/embeddedDocs.js';
+import { hasOwnProperty } from '../../utils/object.js';
+var name = 'help';
+var dependencies = ['typed', 'mathWithTransform', 'Help'];
+export var createHelp = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    mathWithTransform,
+    Help
+  } = _ref;
+  /**
+   * Retrieve help on a function or data type.
+   * Help files are retrieved from the embedded documentation in math.docs.
+   *
+   * Syntax:
+   *
+   *    math.help(search)
+   *
+   * Examples:
+   *
+   *    console.log(math.help('sin').toString())
+   *    console.log(math.help(math.add).toString())
+   *    console.log(math.help(math.add).toJSON())
+   *
+   * @param {Function | string | Object} search   A function or function name
+   *                                              for which to get help
+   * @return {Help} A help object
+   */
+  return typed(name, {
+    any: function any(search) {
+      var prop;
+      var searchName = search;
+      if (typeof search !== 'string') {
+        for (prop in mathWithTransform) {
+          // search in functions and constants
+          if (hasOwnProperty(mathWithTransform, prop) && search === mathWithTransform[prop]) {
+            searchName = prop;
+            break;
+          }
+        }
+
+        /* TODO: implement help for data types
+         if (!text) {
+         // search data type
+         for (prop in math.type) {
+         if (hasOwnProperty(math, prop)) {
+         if (search === math.type[prop]) {
+         text = prop
+         break
+         }
+         }
+         }
+         }
+         */
+      }
+
+      var doc = getSafeProperty(embeddedDocs, searchName);
+      if (!doc) {
+        var searchText = typeof searchName === 'function' ? searchName.name : searchName;
+        throw new Error('No documentation found on "' + searchText + '"');
+      }
+      return new Help(doc);
+    }
+  });
+});

package/lib/esm/expression/function/parser.js

@@ -0,0 +1,57 @@
+import { factory } from '../../utils/factory.js';
+var name = 'parser';
+var dependencies = ['typed', 'Parser'];
+export var createParser = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Parser
+  } = _ref;
+  /**
+   * Create a parser. The function creates a new `math.Parser` object.
+   *
+   * Syntax:
+   *
+   *    math.parser()
+   *
+   * Examples:
+   *
+   *     const parser = new math.parser()
+   *
+   *     // evaluate expressions
+   *     const a = parser.evaluate('sqrt(3^2 + 4^2)') // 5
+   *     const b = parser.evaluate('sqrt(-4)')        // 2i
+   *     const c = parser.evaluate('2 inch in cm')    // 5.08 cm
+   *     const d = parser.evaluate('cos(45 deg)')     // 0.7071067811865476
+   *
+   *     // define variables and functions
+   *     parser.evaluate('x = 7 / 2')             // 3.5
+   *     parser.evaluate('x + 3')                 // 6.5
+   *     parser.evaluate('f(x, y) = x^y')         // f(x, y)
+   *     parser.evaluate('f(2, 3)')               // 8
+   *
+   *     // get and set variables and functions
+   *     const x = parser.get('x')                // 7
+   *     const f = parser.get('f')                // function
+   *     const g = f(3, 2)                        // 9
+   *     parser.set('h', 500)
+   *     const i = parser.evaluate('h / 2')       // 250
+   *     parser.set('hello', function (name) {
+   *       return 'hello, ' + name + '!'
+   *     })
+   *     parser.evaluate('hello("user")')         // "hello, user!"
+   *
+   *     // clear defined functions and variables
+   *     parser.clear()
+   *
+   * See also:
+   *
+   *    evaluate, compile, parse
+   *
+   * @return {Parser} Parser
+   */
+  return typed(name, {
+    '': function _() {
+      return new Parser();
+    }
+  });
+});

package/lib/esm/expression/keywords.js

@@ -0,0 +1,2 @@
+// Reserved keywords not allowed to use in the parser
+export var keywords = new Set(['end']);