mathjs-min 11.7.2

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatDocs = void 0;
+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']
+};
+exports.formatDocs = formatDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasNumericValueDocs = void 0;
+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']
+};
+exports.hasNumericValueDocs = hasNumericValueDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hexDocs = void 0;
+var hexDocs = {
+  name: 'hex',
+  category: 'Utils',
+  syntax: ['hex(value)'],
+  description: 'Format a number as hexadecimal',
+  examples: ['hex(240)'],
+  seealso: ['bin', 'oct']
+};
+exports.hexDocs = hexDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIntegerDocs = void 0;
+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']
+};
+exports.isIntegerDocs = isIntegerDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNaNDocs = void 0;
+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']
+};
+exports.isNaNDocs = isNaNDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNegativeDocs = void 0;
+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']
+};
+exports.isNegativeDocs = isNegativeDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isNumericDocs = void 0;
+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']
+};
+exports.isNumericDocs = isNumericDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPositiveDocs = void 0;
+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']
+};
+exports.isPositiveDocs = isPositiveDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isPrimeDocs = void 0;
+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']
+};
+exports.isPrimeDocs = isPrimeDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isZeroDocs = void 0;
+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']
+};
+exports.isZeroDocs = isZeroDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.numericDocs = void 0;
+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']
+};
+exports.numericDocs = numericDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.octDocs = void 0;
+var octDocs = {
+  name: 'oct',
+  category: 'Utils',
+  syntax: ['oct(value)'],
+  description: 'Format a number as octal',
+  examples: ['oct(56)'],
+  seealso: ['bin', 'hex']
+};
+exports.octDocs = octDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.printDocs = void 0;
+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']
+};
+exports.printDocs = printDocs;

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeOfDocs = void 0;
+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']
+};
+exports.typeOfDocs = typeOfDocs;

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

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCompile = void 0;
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
+var name = 'compile';
+var dependencies = ['typed', 'parse'];
+var createCompile = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    parse = _ref.parse;
+  /**
+   * 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 (0, _collection.deepMap)(expr, function (entry) {
+        return parse(entry).compile();
+      });
+    }
+  });
+});
+exports.createCompile = createCompile;

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEvaluate = void 0;
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
+var _map = require("../../utils/map.js");
+var name = 'evaluate';
+var dependencies = ['typed', 'parse'];
+var createEvaluate = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    parse = _ref.parse;
+  /**
+   * 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 = (0, _map.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 = (0, _map.createEmptyMap)();
+      return (0, _collection.deepMap)(expr, function (entry) {
+        return parse(entry).compile().evaluate(scope);
+      });
+    },
+    'Array | Matrix, Map | Object': function ArrayMatrixMapObject(expr, scope) {
+      return (0, _collection.deepMap)(expr, function (entry) {
+        return parse(entry).compile().evaluate(scope);
+      });
+    }
+  });
+});
+exports.createEvaluate = createEvaluate;

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

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHelp = void 0;
+var _factory = require("../../utils/factory.js");
+var _customs = require("../../utils/customs.js");
+var _embeddedDocs = require("../embeddedDocs/embeddedDocs.js");
+var _object = require("../../utils/object.js");
+var name = 'help';
+var dependencies = ['typed', 'mathWithTransform', 'Help'];
+var createHelp = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    mathWithTransform = _ref.mathWithTransform,
+    Help = _ref.Help;
+  /**
+   * 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 ((0, _object.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 = (0, _customs.getSafeProperty)(_embeddedDocs.embeddedDocs, searchName);
+      if (!doc) {
+        var searchText = typeof searchName === 'function' ? searchName.name : searchName;
+        throw new Error('No documentation found on "' + searchText + '"');
+      }
+      return new Help(doc);
+    }
+  });
+});
+exports.createHelp = createHelp;

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

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createParser = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'parser';
+var dependencies = ['typed', 'Parser'];
+var createParser = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    Parser = _ref.Parser;
+  /**
+   * 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();
+    }
+  });
+});
+exports.createParser = createParser;

package/lib/cjs/expression/keywords.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keywords = void 0;
+// Reserved keywords not allowed to use in the parser
+var keywords = new Set(['end']);
+exports.keywords = keywords;