mathjs-min 11.7.2

package/lib/esm/expression/embeddedDocs/function/algebra/derivative.js

@@ -0,0 +1,8 @@
+export var derivativeDocs = {
+  name: 'derivative',
+  category: 'Algebra',
+  syntax: ['derivative(expr, variable)', 'derivative(expr, variable, {simplify: boolean})'],
+  description: 'Takes the derivative of an expression expressed in parser Nodes. The derivative will be taken over the supplied variable in the second parameter. If there are multiple variables in the expression, it will return a partial derivative.',
+  examples: ['derivative("2x^3", "x")', 'derivative("2x^3", "x", {simplify: false})', 'derivative("2x^2 + 3x + 4", "x")', 'derivative("sin(2x)", "x")', 'f = parse("x^2 + x")', 'x = parse("x")', 'df = derivative(f, x)', 'df.evaluate({x: 3})'],
+  seealso: ['simplify', 'parse', 'evaluate']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/leafCount.js

@@ -0,0 +1,8 @@
+export var leafCountDocs = {
+  name: 'leafCount',
+  category: 'Algebra',
+  syntax: ['leafCount(expr)'],
+  description: 'Computes the number of leaves in the parse tree of the given expression',
+  examples: ['leafCount("e^(i*pi)-1")', 'leafCount(parse("{a: 22/7, b: 10^(1/2)}"))'],
+  seealso: ['simplify']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/lsolve.js

@@ -0,0 +1,8 @@
+export var lsolveDocs = {
+  name: 'lsolve',
+  category: 'Algebra',
+  syntax: ['x=lsolve(L, b)'],
+  description: 'Finds one solution of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
+  examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lsolve(a, b)'],
+  seealso: ['lsolveAll', 'lup', 'lusolve', 'usolve', 'matrix', 'sparse']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/lsolveAll.js

@@ -0,0 +1,8 @@
+export var lsolveAllDocs = {
+  name: 'lsolveAll',
+  category: 'Algebra',
+  syntax: ['x=lsolveAll(L, b)'],
+  description: 'Finds all solutions of the linear system L * x = b where L is an [n x n] lower triangular matrix and b is a [n] column vector.',
+  examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lsolve(a, b)'],
+  seealso: ['lsolve', 'lup', 'lusolve', 'usolve', 'matrix', 'sparse']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/lup.js

@@ -0,0 +1,8 @@
+export var lupDocs = {
+  name: 'lup',
+  category: 'Algebra',
+  syntax: ['lup(m)'],
+  description: 'Calculate the Matrix LU decomposition with partial pivoting. Matrix A is decomposed in three matrices (L, U, P) where P * A = L * U',
+  examples: ['lup([[2, 1], [1, 4]])', 'lup(matrix([[2, 1], [1, 4]]))', 'lup(sparse([[2, 1], [1, 4]]))'],
+  seealso: ['lusolve', 'lsolve', 'usolve', 'matrix', 'sparse', 'slu', 'qr']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/lusolve.js

@@ -0,0 +1,8 @@
+export var lusolveDocs = {
+  name: 'lusolve',
+  category: 'Algebra',
+  syntax: ['x=lusolve(A, b)', 'x=lusolve(lu, b)'],
+  description: 'Solves the linear system A * x = b where A is an [n x n] matrix and b is a [n] column vector.',
+  examples: ['a = [-2, 3; 2, 1]', 'b = [11, 9]', 'x = lusolve(a, b)'],
+  seealso: ['lup', 'slu', 'lsolve', 'usolve', 'matrix', 'sparse']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/polynomialRoot.js

@@ -0,0 +1,8 @@
+export var polynomialRootDocs = {
+  name: 'polynomialRoot',
+  category: 'Algebra',
+  syntax: ['x=polynomialRoot(-6, 3)', 'x=polynomialRoot(4, -4, 1)', 'x=polynomialRoot(-8, 12, -6, 1)'],
+  description: 'Finds the roots of a univariate polynomial given by its coefficients starting from constant, linear, and so on, increasing in degree.',
+  examples: ['a = polynomialRoot(-6, 11, -6 1)'],
+  seealso: ['cbrt', 'sqrt']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/qr.js

@@ -0,0 +1,8 @@
+export var qrDocs = {
+  name: 'qr',
+  category: 'Algebra',
+  syntax: ['qr(A)'],
+  description: 'Calculates the Matrix QR decomposition. Matrix `A` is decomposed in two matrices (`Q`, `R`) where `Q` is an orthogonal matrix and `R` is an upper triangular matrix.',
+  examples: ['qr([[1, -1,  4], [1,  4, -2], [1,  4,  2], [1,  -1, 0]])'],
+  seealso: ['lup', 'slu', 'matrix']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/rationalize.js

@@ -0,0 +1,8 @@
+export var rationalizeDocs = {
+  name: 'rationalize',
+  category: 'Algebra',
+  syntax: ['rationalize(expr)', 'rationalize(expr, scope)', 'rationalize(expr, scope, detailed)'],
+  description: 'Transform a rationalizable expression in a rational fraction. If rational fraction is one variable polynomial then converts the numerator and denominator in canonical form, with decreasing exponents, returning the coefficients of numerator.',
+  examples: ['rationalize("2x/y - y/(x+1)")', 'rationalize("2x/y - y/(x+1)", true)'],
+  seealso: ['simplify']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/resolve.js

@@ -0,0 +1,9 @@
+export var resolveDocs = {
+  name: 'resolve',
+  category: 'Algebra',
+  syntax: ['resolve(node, scope)'],
+  description: 'Recursively substitute variables in an expression tree.',
+  examples: ['resolve(parse("1 + x"), { x: 7 })', 'resolve(parse("size(text)"), { text: "Hello World" })', 'resolve(parse("x + y"), { x: parse("3z") })', 'resolve(parse("3x"), { x: parse("y+z"), z: parse("w^y") })'],
+  seealso: ['simplify', 'evaluate'],
+  mayThrow: ['ReferenceError']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/simplify.js

@@ -0,0 +1,8 @@
+export var simplifyDocs = {
+  name: 'simplify',
+  category: 'Algebra',
+  syntax: ['simplify(expr)', 'simplify(expr, rules)'],
+  description: 'Simplify an expression tree.',
+  examples: ['simplify("3 + 2 / 4")', 'simplify("2x + x")', 'f = parse("x * (x + 2 + x)")', 'simplified = simplify(f)', 'simplified.evaluate({x: 2})'],
+  seealso: ['simplifyCore', 'derivative', 'evaluate', 'parse', 'rationalize', 'resolve']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/simplifyConstant.js

@@ -0,0 +1,8 @@
+export var simplifyConstantDocs = {
+  name: 'simplifyConstant',
+  category: 'Algebra',
+  syntax: ['simplifyConstant(expr)', 'simplifyConstant(expr, options)'],
+  description: 'Replace constant subexpressions of node with their values.',
+  examples: ['simplifyConatant("(3-3)*x")', 'simplifyConstant(parse("z-cos(tau/8)"))'],
+  seealso: ['simplify', 'simplifyCore', 'evaluate']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/simplifyCore.js

@@ -0,0 +1,8 @@
+export var simplifyCoreDocs = {
+  name: 'simplifyCore',
+  category: 'Algebra',
+  syntax: ['simplifyCore(node)'],
+  description: 'Perform simple one-pass simplifications on an expression tree.',
+  examples: ['simplifyCore(parse("0*x"))', 'simplifyCore(parse("(x+0)*2"))'],
+  seealso: ['simplify', 'simplifyConstant', 'evaluate']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/slu.js

@@ -0,0 +1,8 @@
+export var sluDocs = {
+  name: 'slu',
+  category: 'Algebra',
+  syntax: ['slu(A, order, threshold)'],
+  description: 'Calculate the Matrix LU decomposition with full pivoting. Matrix A is decomposed in two matrices (L, U) and two permutation vectors (pinv, q) where P * A * Q = L * U',
+  examples: ['slu(sparse([4.5, 0, 3.2, 0; 3.1, 2.9, 0, 0.9; 0, 1.7, 3, 0; 3.5, 0.4, 0, 1]), 1, 0.001)'],
+  seealso: ['lusolve', 'lsolve', 'usolve', 'matrix', 'sparse', 'lup', 'qr']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/symbolicEqual.js

@@ -0,0 +1,8 @@
+export var symbolicEqualDocs = {
+  name: 'symbolicEqual',
+  category: 'Algebra',
+  syntax: ['symbolicEqual(expr1, expr2)', 'symbolicEqual(expr1, expr2, options)'],
+  description: 'Returns true if the difference of the expressions simplifies to 0',
+  examples: ['symbolicEqual("x*y","y*x")', 'symbolicEqual("abs(x^2)", "x^2")', 'symbolicEqual("abs(x)", "x", {context: {abs: {trivial: true}}})'],
+  seealso: ['simplify', 'evaluate']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/usolve.js

@@ -0,0 +1,8 @@
+export var usolveDocs = {
+  name: 'usolve',
+  category: 'Algebra',
+  syntax: ['x=usolve(U, b)'],
+  description: 'Finds one solution of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
+  examples: ['x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])'],
+  seealso: ['usolveAll', 'lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
+};

package/lib/esm/expression/embeddedDocs/function/algebra/usolveAll.js

@@ -0,0 +1,8 @@
+export var usolveAllDocs = {
+  name: 'usolveAll',
+  category: 'Algebra',
+  syntax: ['x=usolve(U, b)'],
+  description: 'Finds all solutions of the linear system U * x = b where U is an [n x n] upper triangular matrix and b is a [n] column vector.',
+  examples: ['x=usolve(sparse([1, 1, 1, 1; 0, 1, 1, 1; 0, 0, 1, 1; 0, 0, 0, 1]), [1; 2; 3; 4])'],
+  seealso: ['usolve', 'lup', 'lusolve', 'lsolve', 'matrix', 'sparse']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/abs.js

@@ -0,0 +1,8 @@
+export var absDocs = {
+  name: 'abs',
+  category: 'Arithmetic',
+  syntax: ['abs(x)'],
+  description: 'Compute the absolute value.',
+  examples: ['abs(3.5)', 'abs(-4.2)'],
+  seealso: ['sign']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/add.js

@@ -0,0 +1,8 @@
+export var addDocs = {
+  name: 'add',
+  category: 'Operators',
+  syntax: ['x + y', 'add(x, y)'],
+  description: 'Add two values.',
+  examples: ['a = 2.1 + 3.6', 'a - 3.6', '3 + 2i', '3 cm + 2 inch', '"2.3" + "4"'],
+  seealso: ['subtract']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/cbrt.js

@@ -0,0 +1,8 @@
+export var cbrtDocs = {
+  name: 'cbrt',
+  category: 'Arithmetic',
+  syntax: ['cbrt(x)', 'cbrt(x, allRoots)'],
+  description: 'Compute the cubic root value. If x = y * y * y, then y is the cubic root of x. When `x` is a number or complex number, an optional second argument `allRoots` can be provided to return all three cubic roots. If not provided, the principal root is returned',
+  examples: ['cbrt(64)', 'cube(4)', 'cbrt(-8)', 'cbrt(2 + 3i)', 'cbrt(8i)', 'cbrt(8i, true)', 'cbrt(27 m^3)'],
+  seealso: ['square', 'sqrt', 'cube', 'multiply']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/ceil.js

@@ -0,0 +1,8 @@
+export var ceilDocs = {
+  name: 'ceil',
+  category: 'Arithmetic',
+  syntax: ['ceil(x)'],
+  description: 'Round a value towards plus infinity. If x is complex, both real and imaginary part are rounded towards plus infinity.',
+  examples: ['ceil(3.2)', 'ceil(3.8)', 'ceil(-4.2)'],
+  seealso: ['floor', 'fix', 'round']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/cube.js

@@ -0,0 +1,8 @@
+export var cubeDocs = {
+  name: 'cube',
+  category: 'Arithmetic',
+  syntax: ['cube(x)'],
+  description: 'Compute the cube of a value. The cube of x is x * x * x.',
+  examples: ['cube(2)', '2^3', '2 * 2 * 2'],
+  seealso: ['multiply', 'square', 'pow']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/divide.js

@@ -0,0 +1,8 @@
+export var divideDocs = {
+  name: 'divide',
+  category: 'Operators',
+  syntax: ['x / y', 'divide(x, y)'],
+  description: 'Divide two values.',
+  examples: ['a = 2 / 3', 'a * 3', '4.5 / 2', '3 + 4 / 2', '(3 + 4) / 2', '18 km / 4.5'],
+  seealso: ['multiply']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/dotDivide.js

@@ -0,0 +1,8 @@
+export var dotDivideDocs = {
+  name: 'dotDivide',
+  category: 'Operators',
+  syntax: ['x ./ y', 'dotDivide(x, y)'],
+  description: 'Divide two values element wise.',
+  examples: ['a = [1, 2, 3; 4, 5, 6]', 'b = [2, 1, 1; 3, 2, 5]', 'a ./ b'],
+  seealso: ['multiply', 'dotMultiply', 'divide']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/dotMultiply.js

@@ -0,0 +1,8 @@
+export var dotMultiplyDocs = {
+  name: 'dotMultiply',
+  category: 'Operators',
+  syntax: ['x .* y', 'dotMultiply(x, y)'],
+  description: 'Multiply two values element wise.',
+  examples: ['a = [1, 2, 3; 4, 5, 6]', 'b = [2, 1, 1; 3, 2, 5]', 'a .* b'],
+  seealso: ['multiply', 'divide', 'dotDivide']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/dotPow.js

@@ -0,0 +1,8 @@
+export var dotPowDocs = {
+  name: 'dotPow',
+  category: 'Operators',
+  syntax: ['x .^ y', 'dotPow(x, y)'],
+  description: 'Calculates the power of x to y element wise.',
+  examples: ['a = [1, 2, 3; 4, 5, 6]', 'a .^ 2'],
+  seealso: ['pow']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/exp.js

@@ -0,0 +1,8 @@
+export var expDocs = {
+  name: 'exp',
+  category: 'Arithmetic',
+  syntax: ['exp(x)'],
+  description: 'Calculate the exponent of a value.',
+  examples: ['exp(1.3)', 'e ^ 1.3', 'log(exp(1.3))', 'x = 2.4', '(exp(i*x) == cos(x) + i*sin(x))   # Euler\'s formula'],
+  seealso: ['expm', 'expm1', 'pow', 'log']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/expm.js

@@ -0,0 +1,8 @@
+export var expmDocs = {
+  name: 'expm',
+  category: 'Arithmetic',
+  syntax: ['exp(x)'],
+  description: 'Compute the matrix exponential, expm(A) = e^A. ' + 'The matrix must be square. ' + 'Not to be confused with exp(a), which performs element-wise exponentiation.',
+  examples: ['expm([[0,2],[0,0]])'],
+  seealso: ['exp']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/expm1.js

@@ -0,0 +1,8 @@
+export var expm1Docs = {
+  name: 'expm1',
+  category: 'Arithmetic',
+  syntax: ['expm1(x)'],
+  description: 'Calculate the value of subtracting 1 from the exponential value.',
+  examples: ['expm1(2)', 'pow(e, 2) - 1', 'log(expm1(2) + 1)'],
+  seealso: ['exp', 'pow', 'log']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/fix.js

@@ -0,0 +1,8 @@
+export var fixDocs = {
+  name: 'fix',
+  category: 'Arithmetic',
+  syntax: ['fix(x)'],
+  description: 'Round a value towards zero. If x is complex, both real and imaginary part are rounded towards zero.',
+  examples: ['fix(3.2)', 'fix(3.8)', 'fix(-4.2)', 'fix(-4.8)'],
+  seealso: ['ceil', 'floor', 'round']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/floor.js

@@ -0,0 +1,8 @@
+export var floorDocs = {
+  name: 'floor',
+  category: 'Arithmetic',
+  syntax: ['floor(x)'],
+  description: 'Round a value towards minus infinity.If x is complex, both real and imaginary part are rounded towards minus infinity.',
+  examples: ['floor(3.2)', 'floor(3.8)', 'floor(-4.2)'],
+  seealso: ['ceil', 'fix', 'round']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/gcd.js

@@ -0,0 +1,8 @@
+export var gcdDocs = {
+  name: 'gcd',
+  category: 'Arithmetic',
+  syntax: ['gcd(a, b)', 'gcd(a, b, c, ...)'],
+  description: 'Compute the greatest common divisor.',
+  examples: ['gcd(8, 12)', 'gcd(-4, 6)', 'gcd(25, 15, -10)'],
+  seealso: ['lcm', 'xgcd']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/hypot.js

@@ -0,0 +1,8 @@
+export var hypotDocs = {
+  name: 'hypot',
+  category: 'Arithmetic',
+  syntax: ['hypot(a, b, c, ...)', 'hypot([a, b, c, ...])'],
+  description: 'Calculate the hypotenusa of a list with values. ',
+  examples: ['hypot(3, 4)', 'sqrt(3^2 + 4^2)', 'hypot(-2)', 'hypot([3, 4, 5])'],
+  seealso: ['abs', 'norm']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/invmod.js

@@ -0,0 +1,8 @@
+export var invmodDocs = {
+  name: 'invmod',
+  category: 'Arithmetic',
+  syntax: ['invmod(a, b)'],
+  description: 'Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation ax ≣ 1 (mod b)',
+  examples: ['invmod(8, 12)=NaN', 'invmod(7, 13)=2', 'invmod(15151, 15122)=10429'],
+  seealso: ['gcd', 'xgcd']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/lcm.js

@@ -0,0 +1,8 @@
+export var lcmDocs = {
+  name: 'lcm',
+  category: 'Arithmetic',
+  syntax: ['lcm(x, y)'],
+  description: 'Compute the least common multiple.',
+  examples: ['lcm(4, 6)', 'lcm(6, 21)', 'lcm(6, 21, 5)'],
+  seealso: ['gcd']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/log.js

@@ -0,0 +1,8 @@
+export var logDocs = {
+  name: 'log',
+  category: 'Arithmetic',
+  syntax: ['log(x)', 'log(x, base)'],
+  description: 'Compute the logarithm of a value. If no base is provided, the natural logarithm of x is calculated. If base if provided, the logarithm is calculated for the specified base. log(x, base) is defined as log(x) / log(base).',
+  examples: ['log(3.5)', 'a = log(2.4)', 'exp(a)', '10 ^ 4', 'log(10000, 10)', 'log(10000) / log(10)', 'b = log(1024, 2)', '2 ^ b'],
+  seealso: ['exp', 'log1p', 'log2', 'log10']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/log10.js

@@ -0,0 +1,8 @@
+export var log10Docs = {
+  name: 'log10',
+  category: 'Arithmetic',
+  syntax: ['log10(x)'],
+  description: 'Compute the 10-base logarithm of a value.',
+  examples: ['log10(0.00001)', 'log10(10000)', '10 ^ 4', 'log(10000) / log(10)', 'log(10000, 10)'],
+  seealso: ['exp', 'log']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/log1p.js

@@ -0,0 +1,8 @@
+export var log1pDocs = {
+  name: 'log1p',
+  category: 'Arithmetic',
+  syntax: ['log1p(x)', 'log1p(x, base)'],
+  description: 'Calculate the logarithm of a `value+1`',
+  examples: ['log1p(2.5)', 'exp(log1p(1.4))', 'pow(10, 4)', 'log1p(9999, 10)', 'log1p(9999) / log(10)'],
+  seealso: ['exp', 'log', 'log2', 'log10']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/log2.js

@@ -0,0 +1,8 @@
+export var log2Docs = {
+  name: 'log2',
+  category: 'Arithmetic',
+  syntax: ['log2(x)'],
+  description: 'Calculate the 2-base of a value. This is the same as calculating `log(x, 2)`.',
+  examples: ['log2(0.03125)', 'log2(16)', 'log2(16) / log2(2)', 'pow(2, 4)'],
+  seealso: ['exp', 'log1p', 'log', 'log10']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/mod.js

@@ -0,0 +1,8 @@
+export var modDocs = {
+  name: 'mod',
+  category: 'Operators',
+  syntax: ['x % y', 'x mod y', 'mod(x, y)'],
+  description: 'Calculates the modulus, the remainder of an integer division.',
+  examples: ['7 % 3', '11 % 2', '10 mod 4', 'isOdd(x) = x % 2', 'isOdd(2)', 'isOdd(3)'],
+  seealso: ['divide']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/multiply.js

@@ -0,0 +1,8 @@
+export var multiplyDocs = {
+  name: 'multiply',
+  category: 'Operators',
+  syntax: ['x * y', 'multiply(x, y)'],
+  description: 'multiply two values.',
+  examples: ['a = 2.1 * 3.4', 'a / 3.4', '2 * 3 + 4', '2 * (3 + 4)', '3 * 2.1 km'],
+  seealso: ['divide']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/norm.js

@@ -0,0 +1,7 @@
+export var normDocs = {
+  name: 'norm',
+  category: 'Arithmetic',
+  syntax: ['norm(x)', 'norm(x, p)'],
+  description: 'Calculate the norm of a number, vector or matrix.',
+  examples: ['abs(-3.5)', 'norm(-3.5)', 'norm(3 - 4i)', 'norm([1, 2, -3], Infinity)', 'norm([1, 2, -3], -Infinity)', 'norm([3, 4], 2)', 'norm([[1, 2], [3, 4]], 1)', 'norm([[1, 2], [3, 4]], "inf")', 'norm([[1, 2], [3, 4]], "fro")']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/nthRoot.js

@@ -0,0 +1,8 @@
+export var nthRootDocs = {
+  name: 'nthRoot',
+  category: 'Arithmetic',
+  syntax: ['nthRoot(a)', 'nthRoot(a, root)'],
+  description: 'Calculate the nth root of a value. ' + 'The principal nth root of a positive real number A, ' + 'is the positive real solution of the equation "x^root = A".',
+  examples: ['4 ^ 3', 'nthRoot(64, 3)', 'nthRoot(9, 2)', 'sqrt(9)'],
+  seealso: ['nthRoots', 'pow', 'sqrt']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/nthRoots.js

@@ -0,0 +1,8 @@
+export var nthRootsDocs = {
+  name: 'nthRoots',
+  category: 'Arithmetic',
+  syntax: ['nthRoots(A)', 'nthRoots(A, root)'],
+  description: '' + 'Calculate the nth roots of a value. ' + 'An nth root of a positive real number A, ' + 'is a positive real solution of the equation "x^root = A". ' + 'This function returns an array of complex values.',
+  examples: ['nthRoots(1)', 'nthRoots(1, 3)'],
+  seealso: ['sqrt', 'pow', 'nthRoot']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/pow.js

@@ -0,0 +1,8 @@
+export var powDocs = {
+  name: 'pow',
+  category: 'Operators',
+  syntax: ['x ^ y', 'pow(x, y)'],
+  description: 'Calculates the power of x to y, x^y.',
+  examples: ['2^3', '2*2*2', '1 + e ^ (pi * i)', 'pow([[1, 2], [4, 3]], 2)', 'pow([[1, 2], [4, 3]], -1)'],
+  seealso: ['multiply', 'nthRoot', 'nthRoots', 'sqrt']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/round.js

@@ -0,0 +1,8 @@
+export var roundDocs = {
+  name: 'round',
+  category: 'Arithmetic',
+  syntax: ['round(x)', 'round(x, n)'],
+  description: 'round a value towards the nearest integer.If x is complex, both real and imaginary part are rounded towards the nearest integer. When n is specified, the value is rounded to n decimals.',
+  examples: ['round(3.2)', 'round(3.8)', 'round(-4.2)', 'round(-4.8)', 'round(pi, 3)', 'round(123.45678, 2)'],
+  seealso: ['ceil', 'floor', 'fix']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/sign.js

@@ -0,0 +1,8 @@
+export var signDocs = {
+  name: 'sign',
+  category: 'Arithmetic',
+  syntax: ['sign(x)'],
+  description: 'Compute the sign of a value. The sign of a value x is 1 when x>1, -1 when x<0, and 0 when x=0.',
+  examples: ['sign(3.5)', 'sign(-4.2)', 'sign(0)'],
+  seealso: ['abs']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/sqrt.js

@@ -0,0 +1,8 @@
+export var sqrtDocs = {
+  name: 'sqrt',
+  category: 'Arithmetic',
+  syntax: ['sqrt(x)'],
+  description: 'Compute the square root value. If x = y * y, then y is the square root of x.',
+  examples: ['sqrt(25)', '5 * 5', 'sqrt(-1)'],
+  seealso: ['square', 'sqrtm', 'multiply', 'nthRoot', 'nthRoots', 'pow']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/sqrtm.js

@@ -0,0 +1,8 @@
+export var sqrtmDocs = {
+  name: 'sqrtm',
+  category: 'Arithmetic',
+  syntax: ['sqrtm(x)'],
+  description: 'Calculate the principal square root of a square matrix. The principal square root matrix `X` of another matrix `A` is such that `X * X = A`.',
+  examples: ['sqrtm([[33, 24], [48, 57]])'],
+  seealso: ['sqrt', 'abs', 'square', 'multiply']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/square.js

@@ -0,0 +1,8 @@
+export var squareDocs = {
+  name: 'square',
+  category: 'Arithmetic',
+  syntax: ['square(x)'],
+  description: 'Compute the square of a value. The square of x is x * x.',
+  examples: ['square(3)', 'sqrt(9)', '3^2', '3 * 3'],
+  seealso: ['multiply', 'pow', 'sqrt', 'cube']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/subtract.js

@@ -0,0 +1,8 @@
+export var subtractDocs = {
+  name: 'subtract',
+  category: 'Operators',
+  syntax: ['x - y', 'subtract(x, y)'],
+  description: 'subtract two values.',
+  examples: ['a = 5.3 - 2', 'a + 2', '2/3 - 1/6', '2 * 3 - 3', '2.1 km - 500m'],
+  seealso: ['add']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/unaryMinus.js

@@ -0,0 +1,8 @@
+export var unaryMinusDocs = {
+  name: 'unaryMinus',
+  category: 'Operators',
+  syntax: ['-x', 'unaryMinus(x)'],
+  description: 'Inverse the sign of a value. Converts booleans and strings to numbers.',
+  examples: ['-4.5', '-(-5.6)', '-"22"'],
+  seealso: ['add', 'subtract', 'unaryPlus']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/unaryPlus.js

@@ -0,0 +1,8 @@
+export var unaryPlusDocs = {
+  name: 'unaryPlus',
+  category: 'Operators',
+  syntax: ['+x', 'unaryPlus(x)'],
+  description: 'Converts booleans and strings to numbers.',
+  examples: ['+true', '+"2"'],
+  seealso: ['add', 'subtract', 'unaryMinus']
+};

package/lib/esm/expression/embeddedDocs/function/arithmetic/xgcd.js

@@ -0,0 +1,8 @@
+export var xgcdDocs = {
+  name: 'xgcd',
+  category: 'Arithmetic',
+  syntax: ['xgcd(a, b)'],
+  description: 'Calculate the extended greatest common divisor for two values. The result is an array [d, x, y] with 3 entries, where d is the greatest common divisor, and d = x * a + y * b.',
+  examples: ['xgcd(8, 12)', 'gcd(8, 12)', 'xgcd(36163, 21199)'],
+  seealso: ['gcd', 'lcm']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/bitAnd.js

@@ -0,0 +1,8 @@
+export var bitAndDocs = {
+  name: 'bitAnd',
+  category: 'Bitwise',
+  syntax: ['x & y', 'bitAnd(x, y)'],
+  description: 'Bitwise AND operation. Performs the logical AND operation on each pair of the corresponding bits of the two given values by multiplying them. If both bits in the compared position are 1, the bit in the resulting binary representation is 1, otherwise, the result is 0',
+  examples: ['5 & 3', 'bitAnd(53, 131)', '[1, 12, 31] & 42'],
+  seealso: ['bitNot', 'bitOr', 'bitXor', 'leftShift', 'rightArithShift', 'rightLogShift']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/bitNot.js

@@ -0,0 +1,8 @@
+export var bitNotDocs = {
+  name: 'bitNot',
+  category: 'Bitwise',
+  syntax: ['~x', 'bitNot(x)'],
+  description: 'Bitwise NOT operation. Performs a logical negation on each bit of the given value. Bits that are 0 become 1, and those that are 1 become 0.',
+  examples: ['~1', '~2', 'bitNot([2, -3, 4])'],
+  seealso: ['bitAnd', 'bitOr', 'bitXor', 'leftShift', 'rightArithShift', 'rightLogShift']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/bitOr.js

@@ -0,0 +1,8 @@
+export var bitOrDocs = {
+  name: 'bitOr',
+  category: 'Bitwise',
+  syntax: ['x | y', 'bitOr(x, y)'],
+  description: 'Bitwise OR operation. Performs the logical inclusive OR operation on each pair of corresponding bits of the two given values. The result in each position is 1 if the first bit is 1 or the second bit is 1 or both bits are 1, otherwise, the result is 0.',
+  examples: ['5 | 3', 'bitOr([1, 2, 3], 4)'],
+  seealso: ['bitAnd', 'bitNot', 'bitXor', 'leftShift', 'rightArithShift', 'rightLogShift']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/bitXor.js

@@ -0,0 +1,8 @@
+export var bitXorDocs = {
+  name: 'bitXor',
+  category: 'Bitwise',
+  syntax: ['bitXor(x, y)'],
+  description: 'Bitwise XOR operation, exclusive OR. Performs the logical exclusive OR operation on each pair of corresponding bits of the two given values. The result in each position is 1 if only the first bit is 1 or only the second bit is 1, but will be 0 if both are 0 or both are 1.',
+  examples: ['bitOr(1, 2)', 'bitXor([2, 3, 4], 4)'],
+  seealso: ['bitAnd', 'bitNot', 'bitOr', 'leftShift', 'rightArithShift', 'rightLogShift']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/leftShift.js

@@ -0,0 +1,8 @@
+export var leftShiftDocs = {
+  name: 'leftShift',
+  category: 'Bitwise',
+  syntax: ['x << y', 'leftShift(x, y)'],
+  description: 'Bitwise left logical shift of a value x by y number of bits.',
+  examples: ['4 << 1', '8 >> 1'],
+  seealso: ['bitAnd', 'bitNot', 'bitOr', 'bitXor', 'rightArithShift', 'rightLogShift']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/rightArithShift.js

@@ -0,0 +1,8 @@
+export var rightArithShiftDocs = {
+  name: 'rightArithShift',
+  category: 'Bitwise',
+  syntax: ['x >> y', 'rightArithShift(x, y)'],
+  description: 'Bitwise right arithmetic shift of a value x by y number of bits.',
+  examples: ['8 >> 1', '4 << 1', '-12 >> 2'],
+  seealso: ['bitAnd', 'bitNot', 'bitOr', 'bitXor', 'leftShift', 'rightLogShift']
+};

package/lib/esm/expression/embeddedDocs/function/bitwise/rightLogShift.js

@@ -0,0 +1,8 @@
+export var rightLogShiftDocs = {
+  name: 'rightLogShift',
+  category: 'Bitwise',
+  syntax: ['x >>> y', 'rightLogShift(x, y)'],
+  description: 'Bitwise right logical shift of a value x by y number of bits.',
+  examples: ['8 >>> 1', '4 << 1', '-12 >>> 2'],
+  seealso: ['bitAnd', 'bitNot', 'bitOr', 'bitXor', 'leftShift', 'rightArithShift']
+};