mathjs 8.1.0 → 12.2.1

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/sylvester.js

@@ -0,0 +1,8 @@
+export var sylvesterDocs = {
+  name: 'sylvester',
+  category: 'Algebra',
+  syntax: ['sylvester(A,B,C)'],
+  description: 'Solves the real-valued Sylvester equation AX+XB=C for X',
+  examples: ['sylvester([[-1, -2], [1, 1]], [[-2, 1], [-1, 2]], [[-3, 2], [3, 0]])', 'A = [[-1, -2], [1, 1]]; B = [[2, -1], [1, -2]]; C = [[-3, 2], [3, 0]]', 'sylvester(A, B, C)'],
+  seealso: ['schur', 'lyap']
+};

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/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)', 'invmod(7, 13)', 'invmod(15151, 15122)'],
+  seealso: ['gcd', 'xgcd']
+};

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

@@ -3,6 +3,6 @@ export var powDocs = {
   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)'],
+  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

@@ -1,8 +1,8 @@
 export var roundDocs = {
   name: 'round',
   category: 'Arithmetic',
-  syntax: ['round(x)', 'round(x, n)'],
+  syntax: ['round(x)', 'round(x, n)', 'round(unit, valuelessUnit)', 'round(unit, n, valuelessUnit)'],
   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)'],
+  examples: ['round(3.2)', 'round(3.8)', 'round(-4.2)', 'round(-4.8)', 'round(pi, 3)', 'round(123.45678, 2)', 'round(3.241cm, 2, cm)', 'round([3.2, 3.8, -4.7])'],
   seealso: ['ceil', 'floor', 'fix']
 };

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

@@ -3,6 +3,6 @@ export var sqrtmDocs = {
   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([[1, 2], [3, 4]])'],
+  examples: ['sqrtm([[33, 24], [48, 57]])'],
   seealso: ['sqrt', 'abs', 'square', 'multiply']
 };

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

@@ -1,8 +1,8 @@
 export var evaluateDocs = {
   name: 'evaluate',
   category: 'Expression',
-  syntax: ['evaluate(expression)', 'evaluate([expr1, expr2, expr3, ...])'],
+  syntax: ['evaluate(expression)', 'evaluate(expression, scope)', 'evaluate([expr1, expr2, expr3, ...])', 'evaluate([expr1, expr2, expr3, ...], scope)'],
   description: 'Evaluate an expression or an array with expressions.',
-  examples: ['evaluate("2 + 3")', 'evaluate("sqrt(" + 4 + ")")'],
+  examples: ['evaluate("2 + 3")', 'evaluate("sqrt(16)")', 'evaluate("2 inch to cm")', 'evaluate("sin(x * pi)", { "x": 1/2 })', 'evaluate(["width=2", "height=4","width*height"])'],
   seealso: []
 };

package/lib/esm/expression/embeddedDocs/function/matrix/column.js

@@ -4,5 +4,5 @@ export var columnDocs = {
   syntax: ['column(x, index)'],
   description: 'Return a column from a matrix or array.',
   examples: ['A = [[1, 2], [3, 4]]', 'column(A, 1)', 'column(A, 2)'],
-  seealso: ['row']
+  seealso: ['row', 'matrixFromColumns']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/count.js

@@ -0,0 +1,8 @@
+export var countDocs = {
+  name: 'count',
+  category: 'Matrix',
+  syntax: ['count(x)'],
+  description: 'Count the number of elements of a matrix, array or string.',
+  examples: ['a = [1, 2; 3, 4; 5, 6]', 'count(a)', 'size(a)', 'count("hello world")'],
+  seealso: ['size']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/diff.js

@@ -3,6 +3,6 @@ export var diffDocs = {
   category: 'Matrix',
   syntax: ['diff(arr)', 'diff(arr, dim)'],
   description: ['Create a new matrix or array with the difference of the passed matrix or array.', 'Dim parameter is optional and used to indicant the dimension of the array/matrix to apply the difference', 'If no dimension parameter is passed it is assumed as dimension 0', 'Dimension is zero-based in javascript and one-based in the parser', 'Arrays must be \'rectangular\' meaning arrays like [1, 2]', 'If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays'],
-  examples: ['diff([1, 2, 4, 7, 0])', 'diff([1, 2, 4, 7, 0], 0)', 'diff(matrix([1, 2, 4, 7, 0]))', 'diff([[1, 2], [3, 4]])', 'diff([[1, 2], [3, 4]], 0)', 'diff([[1, 2], [3, 4]], 1)', 'diff([[1, 2], [3, 4]], bignumber(1))', 'diff(matrix([[1, 2], [3, 4]]), 1)', 'diff([[1, 2], matrix([3, 4])], 1)'],
+  examples: ['A = [1, 2, 4, 7, 0]', 'diff(A)', 'diff(A, 1)', 'B = [[1, 2], [3, 4]]', 'diff(B)', 'diff(B, 1)', 'diff(B, 2)', 'diff(B, bignumber(2))', 'diff([[1, 2], matrix([3, 4])], 2)'],
   seealso: ['subtract', 'partitionSelect']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/eigs.js

@@ -2,7 +2,7 @@ export var eigsDocs = {
   name: 'eigs',
   category: 'Matrix',
   syntax: ['eigs(x)'],
-  description: 'Calculate the eigenvalues and eigenvectors of a real symmetric matrix',
-  examples: ['eigs([[5, 2.3], [2.3, 1]])'],
+  description: 'Calculate the eigenvalues and optionally eigenvectors of a square matrix',
+  examples: ['eigs([[5, 2.3], [2.3, 1]])', 'eigs([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { precision: 1e-6, eigenvectors: false })'],
   seealso: ['inv']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/fft.js

@@ -0,0 +1,8 @@
+export var fftDocs = {
+  name: 'fft',
+  category: 'Matrix',
+  syntax: ['fft(x)'],
+  description: 'Calculate N-dimensional fourier transform',
+  examples: ['fft([[1, 0], [1, 0]])'],
+  seealso: ['ifft']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/forEach.js

@@ -3,6 +3,6 @@ export var forEachDocs = {
   category: 'Matrix',
   syntax: ['forEach(x, callback)'],
   description: 'Iterates over all elements of a matrix/array, and executes the given callback function.',
-  examples: ['forEach([1, 2, 3], function(val) { console.log(val) })'],
+  examples: ['numberOfPets = {}', 'addPet(n) = numberOfPets[n] = (numberOfPets[n] ? numberOfPets[n]:0 ) + 1;', 'forEach(["Dog","Cat","Cat"], addPet)', 'numberOfPets'],
   seealso: ['map', 'sort', 'filter']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/ifft.js

@@ -0,0 +1,8 @@
+export var ifftDocs = {
+  name: 'ifft',
+  category: 'Matrix',
+  syntax: ['ifft(x)'],
+  description: 'Calculate N-dimensional inverse fourier transform',
+  examples: ['ifft([[2, 2], [0, 0]])'],
+  seealso: ['fft']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/matrixFromColumns.js

@@ -0,0 +1,8 @@
+export var matrixFromColumnsDocs = {
+  name: 'matrixFromColumns',
+  category: 'Matrix',
+  syntax: ['matrixFromColumns(...arr)', 'matrixFromColumns(row1, row2)', 'matrixFromColumns(row1, row2, row3)'],
+  description: 'Create a dense matrix from vectors as individual columns.',
+  examples: ['matrixFromColumns([1, 2, 3], [[4],[5],[6]])'],
+  seealso: ['matrix', 'matrixFromRows', 'matrixFromFunction', 'zeros']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/matrixFromFunction.js

@@ -0,0 +1,8 @@
+export var matrixFromFunctionDocs = {
+  name: 'matrixFromFunction',
+  category: 'Matrix',
+  syntax: ['matrixFromFunction(size, fn)', 'matrixFromFunction(size, fn, format)', 'matrixFromFunction(size, fn, format, datatype)', 'matrixFromFunction(size, format, fn)', 'matrixFromFunction(size, format, datatype, fn)'],
+  description: 'Create a matrix by evaluating a generating function at each index.',
+  examples: ['f(I) = I[1] - I[2]', 'matrixFromFunction([3,3], f)', 'g(I) = I[1] - I[2] == 1 ? 4 : 0', 'matrixFromFunction([100, 100], "sparse", g)', 'matrixFromFunction([5], random)'],
+  seealso: ['matrix', 'matrixFromRows', 'matrixFromColumns', 'zeros']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/matrixFromRows.js

@@ -0,0 +1,8 @@
+export var matrixFromRowsDocs = {
+  name: 'matrixFromRows',
+  category: 'Matrix',
+  syntax: ['matrixFromRows(...arr)', 'matrixFromRows(row1, row2)', 'matrixFromRows(row1, row2, row3)'],
+  description: 'Create a dense matrix from vectors as individual rows.',
+  examples: ['matrixFromRows([1, 2, 3], [[4],[5],[6]])'],
+  seealso: ['matrix', 'matrixFromColumns', 'matrixFromFunction', 'zeros']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/partitionSelect.js

@@ -3,6 +3,6 @@ export var partitionSelectDocs = {
   category: 'Matrix',
   syntax: ['partitionSelect(x, k)', 'partitionSelect(x, k, compare)'],
   description: 'Partition-based selection of an array or 1D matrix. Will find the kth smallest value, and mutates the input array. Uses Quickselect.',
-  examples: ['partitionSelect([5, 10, 1], 2)', 'partitionSelect(["C", "B", "A", "D"], 1)'],
+  examples: ['partitionSelect([5, 10, 1], 2)', 'partitionSelect(["C", "B", "A", "D"], 1, compareText)', 'arr = [5, 2, 1]', 'partitionSelect(arr, 0) # returns 1, arr is now: [1, 2, 5]', 'arr', 'partitionSelect(arr, 1, \'desc\') # returns 2, arr is now: [5, 2, 1]', 'arr'],
   seealso: ['sort']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/pinv.js

@@ -0,0 +1,8 @@
+export var pinvDocs = {
+  name: 'pinv',
+  category: 'Matrix',
+  syntax: ['pinv(x)'],
+  description: 'Calculate the Moore–Penrose inverse of a matrix',
+  examples: ['pinv([1, 2; 3, 4])', 'pinv([[1, 0], [0, 1], [0, 1]])', 'pinv(4)'],
+  seealso: ['inv']
+};

package/lib/esm/expression/embeddedDocs/function/matrix/range.js

@@ -3,6 +3,6 @@ export var rangeDocs = {
   category: 'Type',
   syntax: ['start:end', 'start:step:end', 'range(start, end)', 'range(start, end, step)', 'range(string)'],
   description: 'Create a range. Lower bound of the range is included, upper bound is excluded.',
-  examples: ['1:5', '3:-1:-3', 'range(3, 7)', 'range(0, 12, 2)', 'range("4:10")', 'a = [1, 2, 3, 4; 5, 6, 7, 8]', 'a[1:2, 1:2]'],
+  examples: ['1:5', '3:-1:-3', 'range(3, 7)', 'range(0, 12, 2)', 'range("4:10")', 'range(1m, 1m, 3m)', 'a = [1, 2, 3, 4; 5, 6, 7, 8]', 'a[1:2, 1:2]'],
   seealso: ['concat', 'det', 'diag', 'identity', 'inv', 'ones', 'size', 'squeeze', 'subset', 'trace', 'transpose', 'zeros']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/reshape.js

@@ -3,6 +3,6 @@ export var reshapeDocs = {
   category: 'Matrix',
   syntax: ['reshape(x, sizes)'],
   description: 'Reshape a multi dimensional array to fit the specified dimensions.',
-  examples: ['reshape([1, 2, 3, 4, 5, 6], [2, 3])', 'reshape([[1, 2], [3, 4]], [1, 4])', 'reshape([[1, 2], [3, 4]], [4])'],
+  examples: ['reshape([1, 2, 3, 4, 5, 6], [2, 3])', 'reshape([[1, 2], [3, 4]], [1, 4])', 'reshape([[1, 2], [3, 4]], [4])', 'reshape([1, 2, 3, 4], [-1, 2])'],
   seealso: ['size', 'squeeze', 'resize']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/rotate.js

@@ -3,6 +3,6 @@ export var rotateDocs = {
   category: 'Matrix',
   syntax: ['rotate(w, theta)', 'rotate(w, theta, v)'],
   description: 'Returns a 2-D rotation matrix (2x2) for a given angle (in radians). ' + 'Returns a 2-D rotation matrix (3x3) of a given angle (in radians) around given axis.',
-  examples: ['rotate([1, 0], math.pi / 2)', 'rotate(matrix([1, 0]), unit("35deg"))', 'rotate([1, 0, 0], unit("90deg"), [0, 0, 1])', 'rotate(matrix([1, 0, 0]), unit("90deg"), matrix([0, 0, 1]))'],
+  examples: ['rotate([1, 0], pi / 2)', 'rotate(matrix([1, 0]), unit("35deg"))', 'rotate([1, 0, 0], unit("90deg"), [0, 0, 1])', 'rotate(matrix([1, 0, 0]), unit("90deg"), matrix([0, 0, 1]))'],
   seealso: ['matrix', 'rotationMatrix']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/row.js

@@ -4,5 +4,5 @@ export var rowDocs = {
   syntax: ['row(x, index)'],
   description: 'Return a row from a matrix or array.',
   examples: ['A = [[1, 2], [3, 4]]', 'row(A, 1)', 'row(A, 2)'],
-  seealso: ['column']
+  seealso: ['column', 'matrixFromRows']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/size.js

@@ -4,5 +4,5 @@ export var sizeDocs = {
   syntax: ['size(x)'],
   description: 'Calculate the size of a matrix.',
   examples: ['size(2.3)', 'size("hello world")', 'a = [1, 2; 3, 4; 5, 6]', 'size(a)', 'size(1:6)'],
-  seealso: ['concat', 'det', 'diag', 'identity', 'inv', 'ones', 'range', 'squeeze', 'subset', 'trace', 'transpose', 'zeros']
+  seealso: ['concat', 'count', 'det', 'diag', 'identity', 'inv', 'ones', 'range', 'squeeze', 'subset', 'trace', 'transpose', 'zeros']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/sort.js

@@ -3,6 +3,6 @@ export var sortDocs = {
   category: 'Matrix',
   syntax: ['sort(x)', 'sort(x, compare)'],
   description: 'Sort the items in a matrix. Compare can be a string "asc", "desc", "natural", or a custom sort function.',
-  examples: ['sort([5, 10, 1])', 'sort(["C", "B", "A", "D"])', 'sortByLength(a, b) = size(a)[1] - size(b)[1]', 'sort(["Langdon", "Tom", "Sara"], sortByLength)', 'sort(["10", "1", "2"], "natural")'],
+  examples: ['sort([5, 10, 1])', 'sort(["C", "B", "A", "D"], "natural")', 'sortByLength(a, b) = size(a)[1] - size(b)[1]', 'sort(["Langdon", "Tom", "Sara"], sortByLength)', 'sort(["10", "1", "2"], "natural")'],
   seealso: ['map', 'filter', 'forEach']
 };

package/lib/esm/expression/embeddedDocs/function/matrix/subset.js

@@ -2,7 +2,7 @@ export var subsetDocs = {
   name: 'subset',
   category: 'Matrix',
   syntax: ['value(index)', 'value(index) = replacement', 'subset(value, [index])', 'subset(value, [index], replacement)'],
-  description: 'Get or set a subset of a matrix or string. ' + 'Indexes are one-based. ' + 'Both the ranges lower-bound and upper-bound are included.',
-  examples: ['d = [1, 2; 3, 4]', 'e = []', 'e[1, 1:2] = [5, 6]', 'e[2, :] = [7, 8]', 'f = d * e', 'f[2, 1]', 'f[:, 1]'],
+  description: 'Get or set a subset of the entries of a matrix or ' + 'characters of a string. ' + 'Indexes are one-based. There should be one index specification for ' + 'each dimension of the target. Each specification can be a single ' + 'index, a list of indices, or a range in colon notation `l:u`. ' + 'In a range, both the lower bound l and upper bound u are included; ' + 'and if a bound is omitted it defaults to the most extreme valid value. ' + 'The cartesian product of the indices specified in each dimension ' + 'determines the target of the operation.',
+  examples: ['d = [1, 2; 3, 4]', 'e = []', 'e[1, 1:2] = [5, 6]', 'e[2, :] = [7, 8]', 'f = d * e', 'f[2, 1]', 'f[:, 1]', 'f[[1,2], [1,3]] = [9, 10; 11, 12]', 'f'],
   seealso: ['concat', 'det', 'diag', 'identity', 'inv', 'ones', 'range', 'size', 'squeeze', 'trace', 'transpose', 'zeros']
 };

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

@@ -0,0 +1,8 @@
+export var solveODEDocs = {
+  name: 'solveODE',
+  category: 'Numeric',
+  syntax: ['solveODE(func, tspan, y0)', 'solveODE(func, tspan, y0, options)'],
+  description: 'Numerical Integration of Ordinary Differential Equations.',
+  examples: ['f(t,y) = y', 'tspan = [0, 4]', 'solveODE(f, tspan, 1)', 'solveODE(f, tspan, [1, 2])', 'solveODE(f, tspan, 1, { method:"RK23", maxStep:0.1 })'],
+  seealso: ['derivative', 'simplifyCore']
+};

package/lib/esm/expression/embeddedDocs/function/probability/lgamma.js

@@ -0,0 +1,8 @@
+export var lgammaDocs = {
+  name: 'lgamma',
+  category: 'Probability',
+  syntax: ['lgamma(n)'],
+  description: 'Logarithm of the gamma function for real, positive numbers and complex numbers, ' + 'using Lanczos approximation for numbers and Stirling series for complex numbers.',
+  examples: ['lgamma(4)', 'lgamma(1/2)', 'lgamma(i)', 'lgamma(complex(1.1, 2))'],
+  seealso: ['gamma']
+};

package/lib/esm/expression/embeddedDocs/function/set/setCartesian.js

@@ -2,7 +2,7 @@ export var setCartesianDocs = {
   name: 'setCartesian',
   category: 'Set',
   syntax: ['setCartesian(set1, set2)'],
-  description: 'Create the cartesian product of two (multi)sets. Multi-dimension arrays will be converted to single-dimension arrays before the operation.',
+  description: 'Create the cartesian product of two (multi)sets. Multi-dimension arrays will be converted to single-dimension arrays and the values will be sorted in ascending order before the operation.',
   examples: ['setCartesian([1, 2], [3, 4])'],
   seealso: ['setUnion', 'setIntersect', 'setDifference', 'setPowerset']
 };

package/lib/esm/expression/embeddedDocs/function/signal/freqz.js

@@ -0,0 +1,8 @@
+export var freqzDocs = {
+  name: 'freqz',
+  category: 'Signal',
+  syntax: ['freqz(b, a)', 'freqz(b, a, w)'],
+  description: 'Calculates the frequency response of a filter given its numerator and denominator coefficients.',
+  examples: ['freqz([1, 2], [1, 2, 3])', 'freqz([1, 2], [1, 2, 3], [0, 1])', 'freqz([1, 2], [1, 2, 3], 512)'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/signal/zpk2tf.js

@@ -0,0 +1,8 @@
+export var zpk2tfDocs = {
+  name: 'zpk2tf',
+  category: 'Signal',
+  syntax: ['zpk2tf(z, p, k)'],
+  description: 'Compute the transfer function of a zero-pole-gain model.',
+  examples: ['zpk2tf([1, 2], [-1, -2], 1)', 'zpk2tf([1, 2], [-1, -2])', 'zpk2tf([1 - 3i, 2 + 2i], [-1, -2])'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/special/zeta.js

@@ -0,0 +1,8 @@
+export var zetaDocs = {
+  name: 'zeta',
+  category: 'Special',
+  syntax: ['zeta(s)'],
+  description: 'Compute the Riemann Zeta Function using an infinite series and Riemanns Functional Equation for the entire complex plane',
+  examples: ['zeta(0.2)', 'zeta(-0.5)', 'zeta(4)'],
+  seealso: []
+};

package/lib/esm/expression/embeddedDocs/function/statistics/corr.js

@@ -0,0 +1,8 @@
+export var corrDocs = {
+  name: 'corr',
+  category: 'Statistics',
+  syntax: ['corr(A,B)'],
+  description: 'Compute the correlation coefficient of a two list with values, For matrices, the matrix correlation coefficient is calculated.',
+  examples: ['corr([2, 4, 6, 8],[1, 2, 3, 6])', 'corr(matrix([[1, 2.2, 3, 4.8, 5], [1, 2, 3, 4, 5]]), matrix([[4, 5.3, 6.6, 7, 8], [1, 2, 3, 4, 5]]))'],
+  seealso: ['max', 'mean', 'min', 'median', 'min', 'prod', 'std', 'sum']
+};

package/lib/esm/expression/embeddedDocs/function/statistics/cumsum.js

@@ -0,0 +1,8 @@
+export var cumSumDocs = {
+  name: 'cumsum',
+  category: 'Statistics',
+  syntax: ['cumsum(a, b, c, ...)', 'cumsum(A)'],
+  description: 'Compute the cumulative sum of all values.',
+  examples: ['cumsum(2, 3, 4, 1)', 'cumsum([2, 3, 4, 1])', 'cumsum([1, 2; 3, 4])', 'cumsum([1, 2; 3, 4], 1)', 'cumsum([1, 2; 3, 4], 2)'],
+  seealso: ['max', 'mean', 'median', 'min', 'prod', 'std', 'sum', 'variance']
+};

package/lib/esm/expression/embeddedDocs/function/statistics/max.js

@@ -1,7 +1,7 @@
 export var maxDocs = {
   name: 'max',
   category: 'Statistics',
-  syntax: ['max(a, b, c, ...)', 'max(A)', 'max(A, dim)'],
+  syntax: ['max(a, b, c, ...)', 'max(A)', 'max(A, dimension)'],
   description: 'Compute the maximum value of a list of values.',
   examples: ['max(2, 3, 4, 1)', 'max([2, 3, 4, 1])', 'max([2, 5; 4, 3])', 'max([2, 5; 4, 3], 1)', 'max([2, 5; 4, 3], 2)', 'max(2.7, 7.1, -4.5, 2.0, 4.1)', 'min(2.7, 7.1, -4.5, 2.0, 4.1)'],
   seealso: ['mean', 'median', 'min', 'prod', 'std', 'sum', 'variance']

package/lib/esm/expression/embeddedDocs/function/statistics/mean.js

@@ -1,7 +1,7 @@
 export var meanDocs = {
   name: 'mean',
   category: 'Statistics',
-  syntax: ['mean(a, b, c, ...)', 'mean(A)', 'mean(A, dim)'],
+  syntax: ['mean(a, b, c, ...)', 'mean(A)', 'mean(A, dimension)'],
   description: 'Compute the arithmetic mean of a list of values.',
   examples: ['mean(2, 3, 4, 1)', 'mean([2, 3, 4, 1])', 'mean([2, 5; 4, 3])', 'mean([2, 5; 4, 3], 1)', 'mean([2, 5; 4, 3], 2)', 'mean([1.0, 2.7, 3.2, 4.0])'],
   seealso: ['max', 'median', 'min', 'prod', 'std', 'sum', 'variance']

package/lib/esm/expression/embeddedDocs/function/statistics/min.js

@@ -1,7 +1,7 @@
 export var minDocs = {
   name: 'min',
   category: 'Statistics',
-  syntax: ['min(a, b, c, ...)', 'min(A)', 'min(A, dim)'],
+  syntax: ['min(a, b, c, ...)', 'min(A)', 'min(A, dimension)'],
   description: 'Compute the minimum value of a list of values.',
   examples: ['min(2, 3, 4, 1)', 'min([2, 3, 4, 1])', 'min([2, 5; 4, 3])', 'min([2, 5; 4, 3], 1)', 'min([2, 5; 4, 3], 2)', 'min(2.7, 7.1, -4.5, 2.0, 4.1)', 'max(2.7, 7.1, -4.5, 2.0, 4.1)'],
   seealso: ['max', 'mean', 'median', 'prod', 'std', 'sum', 'variance']

package/lib/esm/expression/embeddedDocs/function/statistics/std.js

@@ -1,7 +1,7 @@
 export var stdDocs = {
   name: 'std',
   category: 'Statistics',
-  syntax: ['std(a, b, c, ...)', 'std(A)', 'std(A, normalization)'],
+  syntax: ['std(a, b, c, ...)', 'std(A)', 'std(A, dimension)', 'std(A, normalization)', 'std(A, dimension, normalization)'],
   description: 'Compute the standard deviation of all values, defined as std(A) = sqrt(variance(A)). Optional parameter normalization can be "unbiased" (default), "uncorrected", or "biased".',
   examples: ['std(2, 4, 6)', 'std([2, 4, 6, 8])', 'std([2, 4, 6, 8], "uncorrected")', 'std([2, 4, 6, 8], "biased")', 'std([1, 2, 3; 4, 5, 6])'],
   seealso: ['max', 'mean', 'min', 'median', 'prod', 'sum', 'variance']

package/lib/esm/expression/embeddedDocs/function/statistics/sum.js

@@ -1,7 +1,7 @@
 export var sumDocs = {
   name: 'sum',
   category: 'Statistics',
-  syntax: ['sum(a, b, c, ...)', 'sum(A)'],
+  syntax: ['sum(a, b, c, ...)', 'sum(A)', 'sum(A, dimension)'],
   description: 'Compute the sum of all values.',
   examples: ['sum(2, 3, 4, 1)', 'sum([2, 3, 4, 1])', 'sum([2, 5; 4, 3])'],
   seealso: ['max', 'mean', 'median', 'min', 'prod', 'std', 'sum', 'variance']

package/lib/esm/expression/embeddedDocs/function/statistics/variance.js

@@ -1,7 +1,7 @@
 export var varianceDocs = {
   name: 'variance',
   category: 'Statistics',
-  syntax: ['variance(a, b, c, ...)', 'variance(A)', 'variance(A, normalization)'],
+  syntax: ['variance(a, b, c, ...)', 'variance(A)', 'variance(A, dimension)', 'variance(A, normalization)', 'variance(A, dimension, normalization)'],
   description: 'Compute the variance of all values. Optional parameter normalization can be "unbiased" (default), "uncorrected", or "biased".',
   examples: ['variance(2, 4, 6)', 'variance([2, 4, 6, 8])', 'variance([2, 4, 6, 8], "uncorrected")', 'variance([2, 4, 6, 8], "biased")', 'variance([1, 2, 3; 4, 5, 6])'],
   seealso: ['max', 'mean', 'min', 'median', 'min', 'prod', 'std', 'sum']

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

@@ -3,6 +3,6 @@ export var numericDocs = {
   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)'],
+  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/print.js

@@ -3,6 +3,6 @@ export var printDocs = {
   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])'],
+  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: $1, $2, $3", [6, 9, 4])'],
   seealso: ['format']
 };

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

@@ -2,12 +2,11 @@ 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) => {
+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

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

@@ -1,13 +1,13 @@
 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) => {
+export var createEvaluate = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     parse
   } = _ref;
-
   /**
    * Evaluate an expression.
    *
@@ -42,19 +42,19 @@ export var createEvaluate = /* #__PURE__ */factory(name, dependencies, (_ref) =>
    */
   return typed(name, {
     string: function string(expr) {
-      var scope = {};
+      var scope = createEmptyMap();
       return parse(expr).compile().evaluate(scope);
     },
-    'string, Object': function stringObject(expr, scope) {
+    'string, Map | Object': function stringMapObject(expr, scope) {
       return parse(expr).compile().evaluate(scope);
     },
     'Array | Matrix': function ArrayMatrix(expr) {
-      var scope = {};
+      var scope = createEmptyMap();
       return deepMap(expr, function (entry) {
         return parse(entry).compile().evaluate(scope);
       });
     },
-    'Array | Matrix, Object': function ArrayMatrixObject(expr, 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

@@ -4,13 +4,12 @@ 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) => {
+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.
@@ -33,7 +32,6 @@ export var createHelp = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     any: function any(search) {
       var prop;
       var searchName = search;
-
       if (typeof search !== 'string') {
         for (prop in mathWithTransform) {
           // search in functions and constants
@@ -42,6 +40,7 @@ export var createHelp = /* #__PURE__ */factory(name, dependencies, (_ref) => {
             break;
           }
         }
+
         /* TODO: implement help for data types
          if (!text) {
          // search data type
@@ -55,16 +54,12 @@ export var createHelp = /* #__PURE__ */factory(name, dependencies, (_ref) => {
          }
          }
          */
-
       }
-
       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

@@ -1,12 +1,11 @@
 import { factory } from '../../utils/factory.js';
 var name = 'parser';
 var dependencies = ['typed', 'Parser'];
-export var createParser = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createParser = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     Parser
   } = _ref;
-
   /**
    * Create a parser. The function creates a new `math.Parser` object.
    *
@@ -25,13 +24,13 @@ export var createParser = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *     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('function f(x, y) = x^y')    // f(x, y)
-   *     parser.evaluate('f(2, 3)')                   // 8
+   *     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 x = parser.get('x')                // 3.5
    *     const f = parser.get('f')                // function
    *     const g = f(3, 2)                        // 9
    *     parser.set('h', 500)

package/lib/esm/expression/keywords.js

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