mathjs 14.2.0 → 14.3.0

package/lib/cjs/utils/array.js

@@ -11,6 +11,8 @@ exports.broadcastTo = broadcastTo;
 exports.checkBroadcastingRules = checkBroadcastingRules;
 exports.clone = clone;
 exports.concat = concat;
+exports.deepForEach = deepForEach;
+exports.deepMap = deepMap;
 exports.filter = filter;
 exports.filterRegExp = filterRegExp;
 exports.flatten = flatten;
@@ -25,7 +27,6 @@ exports.join = join;
 exports.last = last;
 exports.map = map;
 exports.processSizesWildcard = processSizesWildcard;
-exports.recurse = recurse;
 exports.reshape = reshape;
 exports.resize = resize;
 exports.squeeze = squeeze;
@@ -46,7 +47,7 @@ var _object = require("./object.js");
  * This function checks the size of the first entry, it does not validate
  * whether all dimensions match. (use function `validate` for that)
  * @param {Array} x
- * @Return {Number[]} size
+ * @return {number[]} size
  */
 function arraySize(x) {
   const s = [];
@@ -62,7 +63,7 @@ function arraySize(x) {
  * has a size corresponding to the provided size array.
  * @param {Array} array    Array to be validated
  * @param {number[]} size  Array with the size of each dimension
- * @param {number} dim   Current dimension
+ * @param {number} dim     Current dimension
  * @throws DimensionError
  * @private
  */
@@ -83,7 +84,7 @@ function _validate(array, size, dim) {
       _validate(array[i], size, dimNext);
     }
   } else {
-    // last dimension. none of the childs may be an array
+    // last dimension. none of the children may be an array
     for (i = 0; i < len; i++) {
       if (Array.isArray(array[i])) {
         throw new _DimensionError.DimensionError(size.length + 1, size.length, '>');
@@ -114,7 +115,7 @@ function validate(array, size) {
 
 /**
  * Validate whether the source of the index matches the size of the Array
- * @param {Array | Matrix} array    Array to be validated
+ * @param {Array | Matrix} value    Array to be validated
  * @param {Index} index  Index with the source information to validate
  * @throws DimensionError
  */
@@ -147,8 +148,8 @@ function validateIndex(index, length) {
 }
 
 /**
- * Test if and index has empty values
- * @param {number} index    Zero-based index
+ * Test if an index has empty values
+ * @param {Index} index    Zero-based index
  */
 function isEmptyIndex(index) {
   for (let i = 0; i < index._dimensions.length; ++i) {
@@ -174,7 +175,7 @@ function isEmptyIndex(index) {
  * Resize a multi dimensional array. The resized array is returned.
  * @param {Array | number} array         Array to be resized
  * @param {number[]} size Array with the size of each dimension
- * @param {*} [defaultValue=0]  Value to be filled in in new entries,
+ * @param {*} [defaultValue=0]  Value to be filled in new entries,
  *                              zero by default. Specify for example `null`,
  *                              to clearly see entries that are not explicitly
  *                              set.
@@ -212,7 +213,7 @@ function resize(array, size, defaultValue) {
  * @param {Array} array         Array to be resized
  * @param {number[]} size       Array with the size of each dimension
  * @param {number} dim          Current dimension
- * @param {*} [defaultValue]    Value to be filled in in new entries,
+ * @param {*} [defaultValue]    Value to be filled in new entries,
  *                              undefined by default.
  * @private
  */
@@ -302,7 +303,7 @@ function reshape(array, sizes) {
 
 /**
  * Replaces the wildcard -1 in the sizes array.
- * @param {number[]} sizes  List of sizes for each dimension. At most on wildcard.
+ * @param {number[]} sizes  List of sizes for each dimension. At most one wildcard.
  * @param {number} currentLength  Number of elements in the array.
  * @throws {Error}                If more than one wildcard or unable to replace it.
  * @returns {number[]}      The sizes array with wildcard replaced.
@@ -349,7 +350,7 @@ function _reshape(array, sizes) {
   // testing if there are enough elements for the requested shape
   let tmpArray = array;
   let tmpArray2;
-  // for each dimensions starting by the last one and ignoring the first one
+  // for each dimension starting by the last one and ignoring the first one
   for (let sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
     const size = sizes[sizeIndex];
     tmpArray2 = [];
@@ -420,7 +421,7 @@ function _squeeze(array, dims, dim) {
 /**
  * Unsqueeze a multi dimensional array: add dimensions when missing
  *
- * Paramter `size` will be mutated to match the new, unqueezed matrix size.
+ * Parameter `size` will be mutated to match the new, unsqueezed matrix size.
  *
  * @param {Array} array
  * @param {number} dims       Desired number of dimensions of the array
@@ -453,7 +454,7 @@ function unsqueeze(array, dims, outer, size) {
  * @param {Array} array
  * @param {number} dims Required number of dimensions
  * @param {number} dim  Current dimension
- * @returns {Array | *} Returns the squeezed array
+ * @returns {Array | *} Returns the unsqueezed array
  * @private
  */
 function _unsqueeze(array, dims, dim) {
@@ -523,7 +524,7 @@ function filter(array, callback) {
 }
 
 /**
- * Filter values in a callback given a regular expression
+ * Filter values in an array given a regular expression
  * @param {Array} array
  * @param {RegExp} regexp
  * @return {Array} Returns the filtered array
@@ -637,7 +638,7 @@ function getArrayDataType(array, typeOf) {
 
 /**
  * Return the last item from an array
- * @param {array}
+ * @param {Array} array
  * @returns {*}
  */
 function last(array) {
@@ -646,8 +647,8 @@ function last(array) {
 
 /**
  * Get all but the last element of array.
- * @param {array}
- * @returns {*}
+ * @param {Array} array
+ * @returns {Array}
  */
 function initial(array) {
   return array.slice(0, array.length - 1);
@@ -655,7 +656,7 @@ function initial(array) {
 
 /**
  * Recursively concatenate two matrices.
- * The contents of the matrices is not cloned.
+ * The contents of the matrices are not cloned.
  * @param {Array} a             Multi dimensional array
  * @param {Array} b             Multi dimensional array
  * @param {number} concatDim    The dimension on which to concatenate (zero-based)
@@ -684,8 +685,8 @@ function concatRecursive(a, b, concatDim, dim) {
  * Concatenates many arrays in the specified direction
  * @param {...Array} arrays All the arrays to concatenate
  * @param {number} concatDim The dimension on which to concatenate (zero-based)
- * @returns
-*/
+ * @returns {Array}
+ */
 function concat() {
   const arrays = Array.prototype.slice.call(arguments, 0, -1);
   const concatDim = Array.prototype.slice.call(arguments, -1);
@@ -702,9 +703,9 @@ function concat() {
 }
 
 /**
- * Receives two or more sizes and get's the broadcasted size for both.
+ * Receives two or more sizes and gets the broadcasted size for both.
  * @param  {...number[]} sizes Sizes to broadcast together
- * @returns
+ * @returns {number[]} The broadcasted size
  */
 function broadcastSizes() {
   for (var _len = arguments.length, sizes = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -741,16 +742,16 @@ function checkBroadcastingRules(size, toSize) {
   for (let j = 0; j < dim; j++) {
     const n = N - dim + j;
     if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) {
-      throw new Error(`shape missmatch: missmatch is found in arg with shape (${size}) not possible to broadcast dimension ${dim} with size ${size[j]} to size ${toSize[n]}`);
+      throw new Error(`shape mismatch: mismatch is found in arg with shape (${size}) not possible to broadcast dimension ${dim} with size ${size[j]} to size ${toSize[n]}`);
     }
   }
 }
 
 /**
  * Broadcasts a single array to a certain size
- * @param {array} array Array to be broadcasted
+ * @param {Array} array Array to be broadcasted
  * @param {number[]} toSize Size to broadcast the array
- * @returns The broadcasted array
+ * @returns {Array} The broadcasted array
  */
 function broadcastTo(array, toSize) {
   let Asize = arraySize(array);
@@ -781,14 +782,14 @@ function broadcastTo(array, toSize) {
 /**
  * Broadcasts arrays and returns the broadcasted arrays in an array
  * @param  {...Array | any} arrays
- * @returns
+ * @returns {Array[]} The broadcasted arrays
  */
 function broadcastArrays() {
   for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
     arrays[_key2] = arguments[_key2];
   }
   if (arrays.length === 0) {
-    throw new Error('Insuficient number of argumnets in function broadcastArrays');
+    throw new Error('Insufficient number of arguments in function broadcastArrays');
   }
   if (arrays.length === 1) {
     return arrays[0];
@@ -805,11 +806,11 @@ function broadcastArrays() {
 }
 
 /**
- * stretches a matrix up to a certain size in a certain dimension
+ * Stretches a matrix up to a certain size in a certain dimension
  * @param {Array} arrayToStretch
  * @param {number[]} sizeToStretch
  * @param {number} dimToStretch
- * @returns
+ * @returns {Array} The stretched array
  */
 function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
   return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
@@ -819,13 +820,13 @@ function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
 * Retrieves a single element from an array given an index.
 *
 * @param {Array} array - The array from which to retrieve the value.
-* @param {Array<number>} idx - An array of indices specifying the position of the desired element in each dimension.
+* @param {Array<number>} index - An array of indices specifying the position of the desired element in each dimension.
 * @returns {*} - The value at the specified position in the array.
 *
 * @example
 * const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
 * const index = [1, 0, 1];
-* console.log(getValue(arr, index)); // 6
+* console.log(get(arr, index)); // 6
 */
 function get(array, index) {
   if (!Array.isArray(array)) {
@@ -842,30 +843,101 @@ function get(array, index) {
 }
 
 /**
- * Recursive function to map a multi-dimensional array.
+ * Recursively maps over each element of nested array using a provided callback function.
  *
- * @param {*} value - The current value being processed in the array.
- * @param {Array} index - The index of the current value being processed in the array.
- * @param {Array} array - The array being processed.
- * @param {Function} callback - Function that produces the element of the new Array, taking three arguments: the value of the element, the index of the element, and the Array being processed.
- * @returns {*} The new array with each element being the result of the callback function.
- */
-function recurse(value, index, array, callback) {
-  if (Array.isArray(value)) {
-    return value.map(function (child, i) {
-      // we create a copy of the index array and append the new index value
-      return recurse(child, index.concat(i), array, callback);
-    });
-  } else {
-    // invoke the callback function with the right number of arguments
-    return callback(value, index, array);
+ * @param {Array} array - The array to be mapped.
+ * @param {Function} callback - The function to execute on each element, taking three arguments:
+ *   - `value` (any): The current element being processed in the array.
+ *   - `index` (Array<number>): The index of the current element being processed in the array.
+ *   - `array` (Array): The array `deepMap` was called upon.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ * @returns {Array} A new array with each element being the result of the callback function.
+ */
+function deepMap(array, callback) {
+  let skipIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (array.length === 0) {
+    return [];
+  }
+  if (skipIndex) {
+    return recursiveMap(array);
+  }
+  const index = [];
+  return recursiveMapWithIndex(array, 0);
+  function recursiveMapWithIndex(value, depth) {
+    if (Array.isArray(value)) {
+      const N = value.length;
+      const result = Array(N);
+      for (let i = 0; i < N; i++) {
+        index[depth] = i;
+        result[i] = recursiveMapWithIndex(value[i], depth + 1);
+      }
+      return result;
+    } else {
+      return callback(value, index.slice(0, depth), array);
+    }
+  }
+  function recursiveMap(value) {
+    if (Array.isArray(value)) {
+      const N = value.length;
+      const result = Array(N);
+      for (let i = 0; i < N; i++) {
+        result[i] = recursiveMap(value[i]);
+      }
+      return result;
+    } else {
+      return callback(value);
+    }
+  }
+}
+
+/**
+ * Recursively iterates over each element in a multi-dimensional array and applies a callback function.
+ *
+ * @param {Array} array - The multi-dimensional array to iterate over.
+ * @param {Function} callback - The function to execute for each element. It receives three arguments:
+ *   - {any} value: The current element being processed in the array.
+ *   - {Array<number>} index: The index of the current element in each dimension.
+ *   - {Array} array: The original array being processed.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ */
+function deepForEach(array, callback) {
+  let skipIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (array.length === 0) {
+    return;
+  }
+  if (skipIndex) {
+    recursiveForEach(array);
+    return;
+  }
+  const index = [];
+  recursiveForEachWithIndex(array, 0);
+  function recursiveForEachWithIndex(value, depth) {
+    if (Array.isArray(value)) {
+      const N = value.length;
+      for (let i = 0; i < N; i++) {
+        index[depth] = i;
+        recursiveForEachWithIndex(value[i], depth + 1);
+      }
+    } else {
+      callback(value, index.slice(0, depth), array);
+    }
+  }
+  function recursiveForEach(value) {
+    if (Array.isArray(value)) {
+      const N = value.length;
+      for (let i = 0; i < N; i++) {
+        recursiveForEach(value[i]);
+      }
+    } else {
+      callback(value);
+    }
   }
 }
 
 /**
  * Deep clones a multidimensional array
  * @param {Array} array
- * @returns cloned array
+ * @returns {Array} cloned array
  */
 function clone(array) {
   return (0, _extends2.default)([], array);

package/lib/cjs/utils/collection.js

@@ -36,15 +36,9 @@ function containsCollections(array) {
  */
 function deepForEach(array, callback) {
   if ((0, _is.isMatrix)(array)) {
-    array = array.valueOf();
-  }
-  for (let i = 0, ii = array.length; i < ii; i++) {
-    const value = array[i];
-    if (Array.isArray(value)) {
-      deepForEach(value, callback);
-    } else {
-      callback(value);
-    }
+    array.forEach(x => callback(x));
+  } else {
+    (0, _array.deepForEach)(array, callback, true);
   }
 }
 
@@ -61,13 +55,18 @@ function deepForEach(array, callback) {
  * @return {Array | Matrix} res
  */
 function deepMap(array, callback, skipZeros) {
-  if (array && typeof array.map === 'function') {
-    // TODO: replace array.map with a for loop to improve performance
-    return array.map(function (x) {
-      return deepMap(x, callback, skipZeros);
-    });
+  if (!skipZeros) {
+    if ((0, _is.isMatrix)(array)) {
+      return array.map(x => callback(x));
+    } else {
+      return (0, _array.deepMap)(array, callback, true);
+    }
+  }
+  const skipZerosCallback = x => x === 0 ? x : callback(x);
+  if ((0, _is.isMatrix)(array)) {
+    return array.map(x => skipZerosCallback(x));
   } else {
-    return callback(array);
+    return (0, _array.deepMap)(array, skipZerosCallback, true);
   }
 }
 

package/lib/cjs/utils/optimizeCallback.js

@@ -20,9 +20,14 @@ function optimizeCallback(callback, array, name) {
   if (_typedFunction.default.isTypedFunction(callback)) {
     const firstIndex = (array.isMatrix ? array.size() : (0, _array.arraySize)(array)).map(() => 0);
     const firstValue = array.isMatrix ? array.get(firstIndex) : (0, _array.get)(array, firstIndex);
-    const hasSingleSignature = Object.keys(callback.signatures).length === 1;
     const numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array);
-    const fastCallback = hasSingleSignature ? Object.values(callback.signatures)[0] : callback;
+    let fastCallback;
+    if (array.isMatrix && array.dataType !== 'mixed' && array.dataType !== undefined) {
+      const singleSignature = _findSingleSignatureWithArity(callback, numberOfArguments);
+      fastCallback = singleSignature !== undefined ? singleSignature : callback;
+    } else {
+      fastCallback = callback;
+    }
     if (numberOfArguments >= 1 && numberOfArguments <= 3) {
       return function () {
         for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -40,6 +45,18 @@ function optimizeCallback(callback, array, name) {
   }
   return callback;
 }
+function _findSingleSignatureWithArity(callback, arity) {
+  const matchingFunctions = [];
+  Object.entries(callback.signatures).forEach(_ref => {
+    let [signature, func] = _ref;
+    if (signature.split(',').length === arity) {
+      matchingFunctions.push(func);
+    }
+  });
+  if (matchingFunctions.length === 1) {
+    return matchingFunctions[0];
+  }
+}
 function _findNumberOfArguments(callback, value, index, array) {
   const testArgs = [value, index, array];
   for (let i = 3; i > 0; i--) {

package/lib/cjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-const version = exports.version = '14.2.0';
+const version = exports.version = '14.3.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/lib/esm/entry/dependenciesAny/dependenciesMax.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMax } from '../../factoriesAny.js';
 export var maxDependencies = {
+  isNaNDependencies,
   largerDependencies,
   numericDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesAny/dependenciesMaxTransform.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMaxTransform } from '../../factoriesAny.js';
 export var maxTransformDependencies = {
+  isNaNDependencies,
   largerDependencies,
   numericDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesAny/dependenciesMin.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMin } from '../../factoriesAny.js';
 export var minDependencies = {
+  isNaNDependencies,
   numericDependencies,
   smallerDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesAny/dependenciesMinTransform.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMinTransform } from '../../factoriesAny.js';
 export var minTransformDependencies = {
+  isNaNDependencies,
   numericDependencies,
   smallerDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesNumber/dependenciesMax.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMax } from '../../factoriesNumber.js';
 export var maxDependencies = {
+  isNaNDependencies,
   largerDependencies,
   numericDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesNumber/dependenciesMaxTransform.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMaxTransform } from '../../factoriesNumber.js';
 export var maxTransformDependencies = {
+  isNaNDependencies,
   largerDependencies,
   numericDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesNumber/dependenciesMin.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMin } from '../../factoriesNumber.js';
 export var minDependencies = {
+  isNaNDependencies,
   numericDependencies,
   smallerDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesNumber/dependenciesMinTransform.generated.js

@@ -2,11 +2,13 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { isNaNDependencies } from './dependenciesIsNaN.generated.js';
 import { numericDependencies } from './dependenciesNumeric.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createMinTransform } from '../../factoriesNumber.js';
 export var minTransformDependencies = {
+  isNaNDependencies,
   numericDependencies,
   smallerDependencies,
   typedDependencies,

package/lib/esm/entry/impureFunctionsAny.generated.js

@@ -610,6 +610,7 @@ _extends(mathWithTransform, math, {
   }),
   min: createMinTransform({
     config,
+    isNaN,
     numeric,
     smaller,
     typed
@@ -641,6 +642,7 @@ _extends(mathWithTransform, math, {
   }),
   max: createMaxTransform({
     config,
+    isNaN,
     larger,
     numeric,
     typed

package/lib/esm/entry/impureFunctionsNumber.generated.js

@@ -448,12 +448,14 @@ _extends(mathWithTransform, math, {
   }),
   max: createMaxTransform({
     config,
+    isNaN,
     larger,
     numeric,
     typed
   }),
   min: createMinTransform({
     config,
+    isNaN,
     numeric,
     smaller,
     typed

package/lib/esm/entry/pureFunctionsAny.generated.js

@@ -740,12 +740,14 @@ export var matrixFromColumns = /* #__PURE__ */createMatrixFromColumns({
 });
 export var max = /* #__PURE__ */createMax({
   config,
+  isNaN,
   larger,
   numeric,
   typed
 });
 export var min = /* #__PURE__ */createMin({
   config,
+  isNaN,
   numeric,
   smaller,
   typed

package/lib/esm/entry/pureFunctionsNumber.generated.js

@@ -596,12 +596,14 @@ export var corr = /* #__PURE__ */createCorr({
 });
 export var max = /* #__PURE__ */createMax({
   config,
+  isNaN,
   larger,
   numeric,
   typed
 });
 export var min = /* #__PURE__ */createMin({
   config,
+  isNaN,
   numeric,
   smaller,
   typed

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

@@ -5,7 +5,7 @@ export var mapSlicesDocs = {
   description: 'Generate a matrix one dimension less than A by applying callback to ' + 'each slice of A along dimension dim.',
   examples: ['A = [[1, 2], [3, 4]]', 'mapSlices(A, 1, sum)',
   // returns [4, 6]
-  'mapSlices(A, 2, product)' // returns [2, 12]
+  'mapSlices(A, 2, prod)' // returns [2, 12]
   ],
   seealso: ['map', 'forEach']
 };

package/lib/esm/expression/embeddedDocs/function/relational/larger.js

@@ -2,7 +2,7 @@ export var largerDocs = {
   name: 'larger',
   category: 'Relational',
   syntax: ['x > y', 'larger(x, y)'],
-  description: 'Check if value x is larger than y. Returns true if x is larger than y, and false if not.',
+  description: 'Check if value x is larger than y. Returns true if x is larger than y, and false if not. Comparing a value with NaN returns false.',
   examples: ['2 > 3', '5 > 2*2', 'a = 3.3', 'b = 6-2.8', '(a > b)', '(b < a)', '5 cm > 2 inch'],
   seealso: ['equal', 'unequal', 'smaller', 'smallerEq', 'largerEq', 'compare']
 };

package/lib/esm/expression/embeddedDocs/function/relational/smaller.js

@@ -2,7 +2,7 @@ export var smallerDocs = {
   name: 'smaller',
   category: 'Relational',
   syntax: ['x < y', 'smaller(x, y)'],
-  description: 'Check if value x is smaller than value y. Returns true if x is smaller than y, and false if not.',
+  description: 'Check if value x is smaller than value y. Returns true if x is smaller than y, and false if not. Comparing a value with NaN returns false.',
   examples: ['2 < 3', '5 < 2*2', 'a = 3.3', 'b = 6-2.8', '(a < b)', '5 cm < 2 inch'],
   seealso: ['equal', 'unequal', 'larger', 'smallerEq', 'largerEq', 'compare']
 };