chore: add documentation for type checking functions

src/expression/embeddedDocs/embeddedDocs.js

@@ -231,12 +231,55 @@ import { cloneDocs } from './function/utils/clone.js'
 import { formatDocs } from './function/utils/format.js'
 import { hasNumericValueDocs } from './function/utils/hasNumericValue.js'
 import { hexDocs } from './function/utils/hex.js'
+import { isAccessorNodeDocs } from './function/utils/isAccessorNode.js'
+import { isArrayDocs } from './function/utils/isArray.js'
+import { isArrayNodeDocs } from './function/utils/isArrayNode.js'
+import { isAssignmentNodeDocs } from './function/utils/isAssignmentNode.js'
+import { isBigIntDocs } from './function/utils/isBigInt.js'
+import { isBigNumberDocs } from './function/utils/isBigNumber.js'
+import { isBlockNodeDocs } from './function/utils/isBlockNode.js'
+import { isBooleanDocs } from './function/utils/isBoolean.js'
+import { isChainDocs } from './function/utils/isChain.js'
+import { isCollectionDocs } from './function/utils/isCollection.js'
+import { isComplexDocs } from './function/utils/isComplex.js'
+import { isConditionalNodeDocs } from './function/utils/isConditionalNode.js'
+import { isConstantNodeDocs } from './function/utils/isConstantNode.js'
+import { isDateDocs } from './function/utils/isDate.js'
+import { isDenseMatrixDocs } from './function/utils/isDenseMatrix.js'
+import { isFractionDocs } from './function/utils/isFraction.js'
+import { isFunctionDocs } from './function/utils/isFunction.js'
+import { isFunctionAssignmentNodeDocs } from './function/utils/isFunctionAssignmentNode.js'
+import { isFunctionNodeDocs } from './function/utils/isFunctionNode.js'
+import { isHelpDocs } from './function/utils/isHelp.js'
+import { isIndexDocs } from './function/utils/isIndex.js'
+import { isIndexNodeDocs } from './function/utils/isIndexNode.js'
 import { isIntegerDocs } from './function/utils/isInteger.js'
+import { isMapDocs } from './function/utils/isMap.js'
+import { isMatrixDocs } from './function/utils/isMatrix.js'
 import { isNaNDocs } from './function/utils/isNaN.js'
 import { isNegativeDocs } from './function/utils/isNegative.js'
+import { isNodeDocs } from './function/utils/isNode.js'
+import { isNullDocs } from './function/utils/isNull.js'
+import { isNumberDocs } from './function/utils/isNumber.js'
 import { isNumericDocs } from './function/utils/isNumeric.js'
+import { isObjectDocs } from './function/utils/isObject.js'
+import { isObjectNodeDocs } from './function/utils/isObjectNode.js'
+import { isObjectWrappingMapDocs } from './function/utils/isObjectWrappingMap.js'
+import { isOperatorNodeDocs } from './function/utils/isOperatorNode.js'
+import { isParenthesisNodeDocs } from './function/utils/isParenthesisNode.js'
+import { isPartitionedMapDocs } from './function/utils/isPartitionedMap.js'
 import { isPositiveDocs } from './function/utils/isPositive.js'
 import { isPrimeDocs } from './function/utils/isPrime.js'
+import { isRangeDocs } from './function/utils/isRange.js'
+import { isRangeNodeDocs } from './function/utils/isRangeNode.js'
+import { isRegExpDocs } from './function/utils/isRegExp.js'
+import { isRelationalNodeDocs } from './function/utils/isRelationalNode.js'
+import { isResultSetDocs } from './function/utils/isResultSet.js'
+import { isSparseMatrixDocs } from './function/utils/isSparseMatrix.js'
+import { isStringDocs } from './function/utils/isString.js'
+import { isSymbolNodeDocs } from './function/utils/isSymbolNode.js'
+import { isUndefinedDocs } from './function/utils/isUndefined.js'
+import { isUnitDocs } from './function/utils/isUnit.js'
 import { isZeroDocs } from './function/utils/isZero.js'
 import { numericDocs } from './function/utils/numeric.js'
 import { octDocs } from './function/utils/oct.js'
@@ -596,5 +639,48 @@ export const embeddedDocs = {
   isZero: isZeroDocs,
   print: printDocs,
   typeOf: typeOfDocs,
-  numeric: numericDocs
+  numeric: numericDocs,
+  isNumber: isNumberDocs,
+  isComplex: isComplexDocs,
+  isBigNumber: isBigNumberDocs,
+  isBigInt: isBigIntDocs,
+  isFraction: isFractionDocs,
+  isUnit: isUnitDocs,
+  isString: isStringDocs,
+  isArray: isArrayDocs,
+  isMatrix: isMatrixDocs,
+  isCollection: isCollectionDocs,
+  isDenseMatrix: isDenseMatrixDocs,
+  isSparseMatrix: isSparseMatrixDocs,
+  isRange: isRangeDocs,
+  isIndex: isIndexDocs,
+  isBoolean: isBooleanDocs,
+  isResultSet: isResultSetDocs,
+  isHelp: isHelpDocs,
+  isFunction: isFunctionDocs,
+  isDate: isDateDocs,
+  isRegExp: isRegExpDocs,
+  isObject: isObjectDocs,
+  isMap: isMapDocs,
+  isPartitionedMap: isPartitionedMapDocs,
+  isObjectWrappingMap: isObjectWrappingMapDocs,
+  isNull: isNullDocs,
+  isUndefined: isUndefinedDocs,
+  isAccessorNode: isAccessorNodeDocs,
+  isArrayNode: isArrayNodeDocs,
+  isAssignmentNode: isAssignmentNodeDocs,
+  isBlockNode: isBlockNodeDocs,
+  isConditionalNode: isConditionalNodeDocs,
+  isConstantNode: isConstantNodeDocs,
+  isFunctionAssignmentNode: isFunctionAssignmentNodeDocs,
+  isFunctionNode: isFunctionNodeDocs,
+  isIndexNode: isIndexNodeDocs,
+  isNode: isNodeDocs,
+  isObjectNode: isObjectNodeDocs,
+  isOperatorNode: isOperatorNodeDocs,
+  isParenthesisNode: isParenthesisNodeDocs,
+  isRangeNode: isRangeNodeDocs,
+  isRelationalNode: isRelationalNodeDocs,
+  isSymbolNode: isSymbolNodeDocs,
+  isChain: isChainDocs
 }

src/expression/embeddedDocs/function/utils/isAccessorNode.js

@@ -0,0 +1,25 @@
+/**
+ * Test whether a node is a AccessorNode.
+ *
+ * Syntax:
+ *
+ *     math.isAccessorNode(x)
+ *
+ * Examples:
+ *
+ *    math.isAccessorNode()
+ *
+ * See also:
+ *  isNode
+ *
+ * @param {*} x   Node to be tested
+ * @return {boolean}  Returns true when `x` is a accessor node, false otherwise.
+ */
+export const isAccessorNodeDocs = {
+  name: 'isAccessorNode',
+  category: 'Type Checks',
+  syntax: ['isAccessorNode(x)'],
+  description: 'Test whether a value is an AccessorNode.',
+  examples: ['isAccessorNode(math.parse("a[0]"))'],
+  seealso: ['isNode']
+}

src/expression/embeddedDocs/function/utils/isArray.js

@@ -0,0 +1,27 @@
+/**
+ * Test whether a value is an array.
+ *
+ * Syntax:
+ *
+ *     math.isArray(x)
+ *
+ * Examples:
+ *
+ *    math.isArray([1, 2, 3])  // returns true
+ *    math.isArray('123')      // returns false
+ *
+ * See also:
+ *
+ *    isMatrix, isCollection
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is an array, false otherwise.
+ */
+export const isArrayDocs = {
+  name: 'isArray',
+  category: 'Type Checks',
+  syntax: ['isArray(x)'],
+  description: 'Test whether a value is an array.',
+  examples: ['isArray([1, 2, 3])', 'isArray("123")'],
+  seealso: ['isMatrix', 'isCollection']
+}

src/expression/embeddedDocs/function/utils/isArrayNode.js

@@ -0,0 +1,27 @@
+/**
+ * Check if a value is an ArrayNode
+ *
+ * Syntax:
+ *
+ *    math.isArrayNode(x)
+ *
+ * Examples:
+ *
+ *   math.isArrayNode(math.parse("[1,2,3]")) // returns true
+ *
+ * See also:
+ *
+ *  isNode
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is an ArrayNode, false otherwise.
+ */
+
+export const isArrayNodeDocs = {
+  name: 'isArrayNode',
+  category: 'Type Checks',
+  syntax: ['isArrayNode(x)'],
+  description: 'Test whether a value is an ArrayNode.',
+  examples: ['isArrayNode(math.parse("[1,2,3]"))'],
+  seealso: ['isNode']
+}

src/expression/embeddedDocs/function/utils/isAssignmentNode.js

@@ -0,0 +1,26 @@
+/**
+ * Check if a value is an AssignmentNode.
+ *
+ * Syntax:
+ *
+ *    math.isAssignmentNode(x)
+ *
+ * Examples:
+ *
+ *   math.isAssignmentNode(math.parse("a=3")) // returns true
+ *
+ * See also:
+ *
+ *  isNode
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is an AssignmentNode, false otherwise.
+ */
+export const isAssignmentNodeDocs = {
+  name: 'isAssignmentNode',
+  category: 'Type Checks',
+  syntax: ['isAssignmentNode(x)'],
+  description: 'Test whether a value is an AssignmentNode.',
+  examples: ['isAssignmentNode(math.parse("a=3"))'],
+  seealso: ['isNode']
+}

src/expression/embeddedDocs/function/utils/isBigInt.js

@@ -0,0 +1,27 @@
+/**
+ * Test whether a value is a BigInt.
+ *
+ * Syntax:
+ *
+ *     math.isBigInt(x)
+ *
+ * Examples:
+ *
+ *    math.isBigInt(10n)    // returns true
+ *    math.isBigInt(42)     // returns false
+ *
+ * See also:
+ *
+ *    isNumber, isBigNumber
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is a BigInt, false otherwise.
+ */
+export const isBigIntDocs = {
+  name: 'isBigInt',
+  category: 'Type Checks',
+  syntax: ['isBigInt(x)'],
+  description: 'Test whether a value is a BigInt.',
+  examples: ['isBigInt(10n)', 'isBigInt(42)'],
+  seealso: ['isNumber', 'isBigNumber']
+}

src/expression/embeddedDocs/function/utils/isBigNumber.js

@@ -0,0 +1,27 @@
+/**
+ * Test whether a value is a BigNumber.
+ *
+ * Syntax:
+ *
+ *     math.isBigNumber(x)
+ *
+ * Examples:
+ *
+ *    math.isBigNumber(math.bignumber(42))  // returns true
+ *    math.isBigNumber(42)                  // returns false
+ *
+ * See also:
+ *
+ *    isNumber, isFraction
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is a BigNumber, false otherwise.
+ */
+export const isBigNumberDocs = {
+  name: 'isBigNumber',
+  category: 'Type Checks',
+  syntax: ['isBigNumber(x)'],
+  description: 'Test whether a value is a BigNumber.',
+  examples: ['isBigNumber(math.bignumber(42))', 'isBigNumber(42)'],
+  seealso: ['isNumber', 'isFraction']
+}

src/expression/embeddedDocs/function/utils/isBlockNode.js

@@ -0,0 +1,27 @@
+/**
+ * Check if a value is a BlockNode.
+ *
+ * Syntax:
+ *
+ *    math.isBlockNode(x)
+ *
+ * Examples:
+ *
+ *   math.isBlockNode(new math.BlockNode([])) // returns true
+ *
+ * See also:
+ *
+ *  isNode
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is a BlockNode, false otherwise.
+ *
+ */
+export const isBlockNodeDocs = {
+  name: 'isBlockNode',
+  category: 'Type Checks',
+  syntax: ['isBlockNode(x)'],
+  description: 'Test whether a value is a BlockNode.',
+  examples: ['isBlockNode(new math.BlockNode([]))))'],
+  seealso: ['isNode']
+}

src/expression/embeddedDocs/function/utils/isBoolean.js

@@ -0,0 +1,25 @@
+/**
+ * Test whether a value is a boolean.
+ *
+ * Syntax:
+ *
+ *     math.isBoolean(x)
+ *
+ * Examples:
+ *
+ *    math.isBoolean(true)
+ *
+ * See also:
+ *  isNumber, isString, isArray, isObject
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is a boolean, false otherwise.
+ */
+export const isBooleanDocs = {
+  name: 'isBoolean',
+  category: 'Type Checks',
+  syntax: ['isBoolean(x)'],
+  description: 'Check if a value is a boolean.',
+  examples: ['isBoolean(true)', 'isBoolean(false)'],
+  seealso: ['isNumber', 'isString', 'isArray', 'isObject']
+}

src/expression/embeddedDocs/function/utils/isChain.js

@@ -0,0 +1,26 @@
+/**
+ * Test whether a value is a Chain (used for chained operations).
+ *
+ * Syntax:
+ *
+ *    math.isChain(x)
+ *
+ * Examples:
+ *
+ *   math.isChain(math.chain(3))
+ *
+ * See also:
+ *  chain
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is a Chain, false otherwise.
+ *
+ */
+export const isChainDocs = {
+  name: 'isChain',
+  category: 'Type Checks',
+  syntax: ['isChain(x)'],
+  description: 'Test whether a value is a Chain (used for chained operations).',
+  examples: ['isChain(math.chain(3))', 'isChain(3)'],
+  seealso: ['chain']
+}

src/expression/embeddedDocs/function/utils/isCollection.js

@@ -0,0 +1,27 @@
+/**
+ * Test whether a value is a Collection.
+ *
+ * Syntax:
+ *
+ *     math.isCollection(x)
+ *
+ * Examples:
+ *
+ *    math.isCollection([1, 2, 3])  // returns true
+ *    math.isCollection(42)         // returns false
+ *
+ * See also:
+ *
+ *    isArray, isMatrix
+ *
+ * @param {*} x   Value to be tested
+ * @return {boolean}  Returns true when `x` is a Collection, false otherwise.
+ */
+export const isCollectionDocs = {
+  name: 'isCollection',
+  category: 'Type Checks',
+  syntax: ['isCollection(x)'],
+  description: 'Test whether a value is a Collection.',
+  examples: ['isCollection([1,2,3])', 'isCollection(42)'],
+  seealso: ['isArray', 'isMatrix']
+}