Mathjs
Math.js 是一个功能丰富的 JavaScript 和 Node.js 数学库。
函数参考
表达式
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| compile | 解析并编译表达式（负责解析，不直接返回结果）。 | compile('2 + 3') | 表达式（字符串） | {} |
| evaluate | 计算表达式并返回结果。 | evaluate('2 + 3') | 表达式（字符串），作用域（可选） | 5 |
| help | 检索函数或数据类型的使用说明。 | help('evaluate') | 搜索关键字（字符串） | { "name": "evaluate", "category": "Excodession", "syntax": [ "evaluate(excodession)", "evaluate(excodession, scope)", "evaluate([expr1, expr2, expr3, ...])", "evaluate([expr1, expr2, expr3, ...], scope)" ], "description": "Evaluate an excodession or an array with excodessions.", "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": [], "mathjs": "Help"} |
| parser | 创建自定义操作用的解析器。 | parser() | 无 | {} |
代数计算
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| derivative | 对表达式进行求导，并指定变量。 | derivative('x^2', 'x') | 表达式（字符串或节点），变量（字符串） | { "mathjs": "OperatorNode", "op": "*", "fn": "multiply", "args": [ { "mathjs": "ConstantNode", "value": 2 }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false} |
| leafCount | 统计表达式解析树中的叶节点数量（符号或常量）。 | leafCount('x^2 + y') | 表达式（字符串或节点） | 3 |
| lsolve | 使用前向替换法求解线性方程组的一个解。 | lsolve([[1,2],[3,4]], [5,6]) | L（数组或矩阵），b（数组或矩阵） | [ [ 5 ], [ -2.25 ]] |
| lsolveAll | 使用前向替换法求解线性方程组的所有解。 | lsolveAll([[1,2],[3,4]], [5,6]) | L（数组或矩阵），b（数组或矩阵） | [ [ [ 5 ], [ -2.25 ] ]] |
| lup | 对矩阵执行部分主元LU分解。 | lup([[1,2],[3,4]]) | A（数组或矩阵） | { "L": [ [ 1, 0 ], [ 0.3333333333333333, 1 ] ], "U": [ [ 3, 4 ], [ 0, 0.6666666666666667 ] ], "p": [ 1, 0 ]} |
| lusolve | 求解线性方程 A*x=b（A 为 n×n 矩阵）。 | lusolve([[1,2],[3,4]], [5,6]) | A（数组或矩阵），b（数组或矩阵） | [ [ -3.9999999999999987 ], [ 4.499999999999999 ]] |
| qr | 对矩阵执行 QR 分解。 | qr([[1,2],[3,4]]) | A（数组或矩阵） | { "Q": [ [ 0.316227766016838, 0.9486832980505138 ], [ 0.9486832980505138, -0.316227766016838 ] ], "R": [ [ 3.162277660168379, 4.427188724235731 ], [ 0, 0.6324555320336751 ] ]} |
| rationalize | 将可有理化的表达式转换为有理分式。 | rationalize('1/(x+1)') | 表达式（字符串或节点） | { "mathjs": "OperatorNode", "op": "/", "fn": "divide", "args": [ { "mathjs": "ConstantNode", "value": 1 }, { "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "SymbolNode", "name": "x" }, { "mathjs": "ConstantNode", "value": 1 } ], "implicit": false, "isPercentage": false } ], "implicit": false, "isPercentage": false} |
| resolve | 用给定作用域中的值替换表达式中的变量。 | resolve('x + y', {x:2, y:3}) | 表达式（字符串或节点），作用域（对象） | { "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "ConstantNode", "value": 2 }, { "mathjs": "ConstantNode", "value": 3 } ], "implicit": false, "isPercentage": false} |
| simplify | 简化表达式解析树（合并同类项等）。 | simplify('2x + 3x') | 表达式（字符串或节点） | { "mathjs": "OperatorNode", "op": "*", "fn": "multiply", "args": [ { "mathjs": "ConstantNode", "value": 5 }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false} |
| simplifyCore | 单次传递（one-pass）简化表达式，多用于性能敏感场景。 | simplifyCore('x+x') | 表达式（字符串或节点） | { "mathjs": "OperatorNode", "op": "+", "fn": "add", "args": [ { "mathjs": "SymbolNode", "name": "x" }, { "mathjs": "SymbolNode", "name": "x" } ], "implicit": false, "isPercentage": false} |
| slu | 以完全主元方式计算稀疏 LU 分解。 | slu(sparse([[4,3], [6, 3]]), 1, 0.001) | A（数组或矩阵），分解顺序（字符串），阈值（数字） | { "L": { "mathjs": "SparseMatrix", "values": [ 1, 1.5, 1 ], "index": [ 0, 1, 1 ], "ptr": [ 0, 2, 3 ], "size": [ 2, 2 ] }, "U": { "mathjs": "SparseMatrix", "values": [ 4, 3, -1.5 ], "index": [ 0, 0, 1 ], "ptr": [ 0, 1, 3 ], "size": [ 2, 2 ] }, "p": [ 0, 1 ], "q": [ 0, 1 ]} |
| symbolicEqual | 检测两个表达式在符号意义上是否相等。 | symbolicEqual('x+x', '2x') | 表达式1（字符串或节点），表达式2（字符串或节点） | true |
| usolve | 使用回代法求解线性方程组的一个解。 | usolve([[1,2],[0,1]], [3,4]) | U（数组或矩阵），b（数组或矩阵） | [ [ -5 ], [ 4 ]] |
| usolveAll | 使用回代法求解线性方程组的所有解。 | usolveAll([[1,2],[0,1]], [3,4]) | U（数组或矩阵），b（数组或矩阵） | [ [ [ -5 ], [ 4 ] ]] |
算术计算
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| abs | 计算一个数的绝对值。 | abs(-3.2) | x（数字、复数、数组或矩阵） | 3.2 |
| add | 将两个或更多数值相加（x + y）。 | add(2, 3) | x、y、…（数字、数组或矩阵） | 5 |
| cbrt | 计算一个数的立方根，可选地计算所有立方根。 | cbrt(8) | x（数字或复数），allRoots（布尔，可选） | 2 |
| ceil | 向正无穷方向取整（对于复数则对实部和虚部分别取整）。 | ceil(3.2) | x（数字、复数、数组或矩阵） | 4 |
| cube | 计算一个数的立方 (xxx)。 | cube(3) | x（数字、复数、数组或矩阵） | 27 |
| divide | 两个值相除 (x / y)。 | divide(6, 2) | x（数字、数组或矩阵），y（数字、数组或矩阵） | 3 |
| dotDivide | 逐元素地对两个矩阵或数组执行除法。 | dotDivide([6,8],[2,4]) | x（数组或矩阵），y（数组或矩阵） | [ 3, 2] |
| dotMultiply | 逐元素地对两个矩阵或数组执行乘法。 | dotMultiply([2,3],[4,5]) | x（数组或矩阵），y（数组或矩阵） | [ 8, 15] |
| dotPow | 逐元素地对 x^y 求幂。 | dotPow([2,3],[2,3]) | x（数组或矩阵），y（数组或矩阵） | [ 4, 27] |
| exp | 计算 e^x。 | exp(1) | x（数字、复数、数组或矩阵） | 2.718281828459045 |
| expm1 | 计算 e^x - 1。 | expm1(1) | x（数字或复数） | 1.718281828459045 |
| fix | 向零方向取整（截断）。 | fix(3.7) | x（数字、复数、数组或矩阵） | 3 |
| floor | 向负无穷方向取整。 | floor(3.7) | x（数字、复数、数组或矩阵） | 3 |
| gcd | 求两个或更多数的最大公约数。 | gcd(8, 12) | a, b, ...（数字或大数） | 4 |
| hypot | 计算多个数的平方和的平方根（如勾股定理）。 | hypot(3, 4) | a, b, …（数字或大数） | 5 |
| invmod | 计算 a 在模 b 意义下的乘法逆元。 | invmod(3, 11) | a, b（数字或大数） | 4 |
| lcm | 求两个或更多数的最小公倍数。 | lcm(4, 6) | a, b, ...（数字或大数） | 12 |
| log | 计算对数（可指定底）。 | log(100, 10) | x（数字或复数），base（可选，数字或复数） | 2 |
| log10 | 计算一个数的 10 进制对数。 | log10(100) | x（数字或复数） | 2 |
| log1p | 计算 ln(1 + x)。 | log1p(1) | x（数字或复数） | 0.6931471805599453 |
| log2 | 计算一个数的 2 进制对数。 | log2(8) | x（数字或复数） | 3 |
| mod | 计算 x ÷ y 的余数（x mod y）。 | mod(8,3) | x, y（数字或大数） | 2 |
| multiply | 将两个或更多数值相乘（x * y）。 | multiply(2, 3) | x、y、…（数字、数组或矩阵） | 6 |
| norm | 计算数字、向量或矩阵的范数，可选 p。 | norm([3,4]) | x（数组或矩阵），p（数字或字符串，可选） | 5 |
| nthRoot | 计算一个数的 n 次方根（主根）。 | nthRoot(16, 4) | a（数字、大数或复数），root（可选，数字） | 2 |
| nthRoots | 计算一个数的所有 n 次方根，可能包含复数解。 | nthRoots(1,3) | x（数字或复数），root（数字） | [ { "mathjs": "Complex", "re": 1, "im": 0 }, { "mathjs": "Complex", "re": -0.4999999999999998, "im": 0.8660254037844387 }, { "mathjs": "Complex", "re": -0.5000000000000004, "im": -0.8660254037844384 }] |
| pow | 计算 x^y。 | pow(2, 3) | x（数字、复数、数组或矩阵），y（数字、复数、数组或矩阵） | 8 |
| round | 四舍五入到指定的小数位数。 | round(3.14159, 2) | x（数字、复数、数组或矩阵），n（可选，数字） | 3.14 |
| sign | 计算数值的符号（-1、0 或 1）。 | sign(-3) | x（数字、大数或复数） | -1 |
| sqrt | 计算一个数的平方根。 | sqrt(9) | x（数字、复数、数组或矩阵） | 3 |
| square | 计算一个数的平方 (x*x)。 | square(3) | x（数字、复数、数组或矩阵） | 9 |
| subtract | 两个数相减 (x - y)。 | subtract(8, 3) | x, y（数字、数组或矩阵） | 5 |
| unaryMinus | 对值执行一元负操作（取反）。 | unaryMinus(3) | x（数字、复数、数组或矩阵） | -3 |
| unaryPlus | 对值执行一元加操作（通常无实际变化）。 | unaryPlus(-3) | x（数字、复数、数组或矩阵） | -3 |
| xgcd | 计算两个数的扩展最大公约数。 | xgcd(8, 12) | a, b（数字或大数） | { "mathjs": "DenseMatrix", "data": [ 4, -1, 1 ], "size": [ 3 ]} |
位运算
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| bitAnd | 对两个值进行按位与 (x & y)。 | bitAnd(5, 3) | x, y（数字或大数） | 1 |
| bitNot | 对值执行按位取反 (~x)。 | bitNot(5) | x（数字或大数） | -6 |
| bitOr | 对两个值进行按位或 (x \ | y)。 | bitOr(5, 3) | x, y（数字或大数） |
| bitXor | 对两个值进行按位异或 (x ^ y)。 | bitXor(5, 3) | x, y（数字或大数） | 6 |
| leftShift | 将 x 的二进制位左移 y 位 (x << y)。 | leftShift(5, 1) | x, y（数字或大数） | 10 |
| rightArithShift | 对 x 的二进制位进行算术右移 (x >> y)。 | rightArithShift(5, 1) | x, y（数字或大数） | 2 |
| rightLogShift | 对 x 的二进制位进行逻辑右移 (x >>> y)。 | rightLogShift(5, 1) | x, y（数字或大数） | 2 |
组合学
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| bellNumbers | 计算 n 个互异元素的所有划分方式数量。 | bellNumbers(3) | n（数字） | 5 |
| catalan | 计算 n 的卡塔兰数，对应多种组合结构计数。 | catalan(5) | n（数字） | 42 |
| composition | 计算将 n 拆分成 k 部分的组合数。 | composition(5, 3) | n, k（数字） | 6 |
| stirlingS2 | 计算将 n 个有标签的元素划分为 k 个非空子集的方式（第二类斯特林数）。 | stirlingS2(5, 3) | n, k（数字） | 25 |
复数
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| arg | 计算复数的幅角（相位）。 | arg(complex('2 + 2i')) | x（复数或数字） | 0.785398163 |
| conj | 计算复数的共轭。 | conj(complex('2 + 2i')) | x（复数或数字） | { "mathjs": "Complex", "re": 2, "im": -2} |
| im | 获取复数的虚部。 | im(complex('2 + 3i')) | x（复数或数字） | 3 |
| re | 获取复数的实部。 | re(complex('2 + 3i')) | x（复数或数字） | 2 |
几何
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| distance | 计算 N 维空间中两点之间的欧几里得距离。 | distance([0,0],[3,4]) | point1（数组），point2（数组） | 5 |
| intersect | 求两条线（二维/三维）或一条线与一个平面（三维）的交点。 | intersect([0,0],[2,2],[0,2],[2,0]) | 直线1的起点与终点，直线2的起点与终点，... | [ 1, 1] |
逻辑
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| and | 执行逻辑与运算。 | and(true, false) | x, y（布尔值或数字） | false |
| not | 执行逻辑非运算。 | not(true) | x（布尔值或数字） | false |
| or | 执行逻辑或运算。 | or(true, false) | x, y（布尔值或数字） | true |
| xor | 执行逻辑异或运算。 | xor(1, 0) | x, y（布尔值或数字） | true |
矩阵
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| column | 从矩阵中返回指定列。 | column([[1,2],[3,4]], 1) | value（矩阵或数组），index（数字） | [ [ 1 ], [ 3 ]] |
| concat | 沿指定维度拼接多个矩阵/数组。 | concat([1,2], [3,4], [5,6]) | a, b, c, ...（数组或矩阵），dim（数字，可选） | [ 1, 2, 3, 4, 5, 6] |
| count | 统计矩阵、数组或字符串的元素数量。 | count([1,2,3,'hello']) | x（数组、矩阵或字符串） | 4 |
| cross | 计算两个三维向量的叉积。 | cross([1,2,3], [4,5,6]) | x, y（长度为3的数组或矩阵） | [ -3, 6, -3] |
| ctranspose | 对矩阵进行转置并取共轭。 | ctranspose([[1,2],[3,4]]) | x（矩阵或数组） | [ [ 1, 3 ], [ 2, 4 ]] |
| det | 计算矩阵的行列式。 | det([[1,2],[3,4]]) | x（矩阵或数组） | -2 |
| diag | 创建对角矩阵或提取矩阵的对角线。 | diag([1,2,3]) | X（数组或矩阵） | [ [ 1, 0, 0 ], [ 0, 2, 0 ], [ 0, 0, 3 ]] |
| diff | 计算指定维度上相邻元素之间的差值。 | diff([1,4,9,16]) | arr（数组或矩阵），dim（数字，可选） | [ 3, 5, 7] |
| dot | 计算两个向量的点积。 | dot([1,2,3],[4,5,6]) | x, y（数组或矩阵） | 32 |
| eigs | 计算方阵的特征值和（可选）特征向量。 | eigs([[1,2],[3,4]]) | x（矩阵或数组），codec（数值，可选） | { "values": [ -0.37228132326901653, 5.372281323269014 ], "eigenvectors": [ { "value": -0.37228132326901653, "vector": [ -4.505883335311908, 3.091669772938812 ] }, { "value": 5.372281323269014, "vector": [ 0.4438641329939267, 0.9703494293791691 ] } ]} |
| expm | 计算矩阵的指数 e^A。 | expm([[1,0],[0,1]]) | x（矩阵或数组） | { "mathjs": "DenseMatrix", "data": [ [ 2.7182818284590424, 0 ], [ 0, 2.7182818284590424 ] ], "size": [ 2, 2 ]} |
| fft | 计算 N 维快速傅里叶变换。 | fft([1,2,3,4]) | arr（数组或矩阵） | [ { "mathjs": "Complex", "re": 10, "im": 0 }, { "mathjs": "Complex", "re": -2, "im": 2 }, { "mathjs": "Complex", "re": -2, "im": 0 }, { "mathjs": "Complex", "re": -1.9999999999999998, "im": -2 }] |
| filter | （暂不支持）使用测试函数过滤数组或一维矩阵。 | filter(['23', 'foo', '100', '55', 'bar'], /[0-9]+/) | x（数组或矩阵），test（函数） | [ "23", "100", "55"] |
| flatten | 将多维矩阵或数组展开为一维。 | flatten([[1,2],[3,4]]) | x（数组或矩阵） | [ 1, 2, 3, 4] |
| forEach | （暂不支持）遍历矩阵/数组的每个元素并执行回调。 | forEach([1,2,3], val => console.log(val)) | x（数组或矩阵），callback（函数） | undefined |
| getMatrixDataType | 查看矩阵或数组所有元素的数据类型，例如 'number' 或 'Complex'。 | getMatrixDataType([[1,2.2],[3,'hello']]) | x（数组或矩阵） | mixed |
| identity | 创建 n x n（或 m x n）的单位矩阵。 | identity(3) | n（数字）或 [m, n]（数组） | { "mathjs": "DenseMatrix", "data": [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ], "size": [ 3, 3 ]} |
| ifft | 计算 N 维逆快速傅里叶变换。 | ifft([1,2,3,4]) | arr（数组或矩阵） | [ { "mathjs": "Complex", "re": 2.5, "im": 0 }, { "mathjs": "Complex", "re": -0.5, "im": -0.5 }, { "mathjs": "Complex", "re": -0.5, "im": 0 }, { "mathjs": "Complex", "re": -0.49999999999999994, "im": 0.5 }] |
| inv | 计算方阵的逆矩阵。 | inv([[1,2],[3,4]]) | x（矩阵或数组） | [ [ -2, 1 ], [ 1.5, -0.5 ]] |
| kron | 计算两个矩阵或向量的克罗内克积。 | kron([[1,1],[0,1]], [[2,0],[0,2]]) | x, y（矩阵或数组） | [ [ 2, 0, 2, 0 ], [ 0, 2, 0, 2 ], [ 0, 0, 2, 0 ], [ 0, 0, 0, 2 ]] |
| map | 通过对每个元素应用回调创建新的数组/矩阵。 | map([1,2,3], val => val * val) | x（数组或矩阵），callback（函数） | [ 1, 4, 9] |
| matrixFromColumns | 将多个向量作为单独列组合成一个稠密矩阵。 | matrixFromColumns([1,4],[2,5],[3,6]) | ...arr（数组或矩阵） | [ [ 1, 2, 3 ], [ 4, 5, 6 ]] |
| matrixFromFunction | (暂不支持) 根据函数对矩阵每个索引进行求值来生成矩阵。 | matrixFromFunction([5], i => math.random()) | size（数组），fn（函数） | a random vector |
| matrixFromRows | 将多个向量作为单独行组合成一个稠密矩阵。 | matrixFromRows([1,2,3],[4,5,6]) | ...arr（数组或矩阵） | [ [ 1, 2, 3 ], [ 4, 5, 6 ]] |
| ones | 创建给定维度的全 1 矩阵。 | ones(2, 3) | m, n, p...（数字） | { "mathjs": "DenseMatrix", "data": [ [ 1, 1, 1 ], [ 1, 1, 1 ] ], "size": [ 2, 3 ]} |
| partitionSelect | 基于分区选择法，从数组或一维矩阵返回第 k 小的元素。 | partitionSelect([3,1,4,2], 2) | x（数组或矩阵），k（数字） | 3 |
| pinv | 计算矩阵的 Moore–Penrose 伪逆。 | pinv([[1,2],[2,4]]) | x（矩阵或数组） | [ [ 0.04000000000000001, 0.08000000000000002 ], [ 0.08000000000000002, 0.16000000000000003 ]] |
| range | 从 start 到 end 生成一个数字数组（step 可选）。 | range(1, 5, 2) | start（数字），end（数字），step（数字，可选） | { "mathjs": "DenseMatrix", "data": [ 1, 3 ], "size": [ 2 ]} |
| reshape | 将数组/矩阵重塑为指定维度。 | reshape([1,2,3,4,5,6], [2,3]) | x（数组或矩阵），sizes（数组） | [ [ 1, 2, 3 ], [ 4, 5, 6 ]] |
| resize | 将矩阵调整为新维度，可用默认值填充缺失元素。 | resize([1,2,3], [5], 0) | x（数组或矩阵），size（数组），defaultValue（可选） | [ 1, 2, 3, 0, 0] |
| rotate | 将 1x2 向量逆时针旋转一定角度，或对 1x3 向量绕给定轴旋转。 | rotate([1, 0], Math.PI / 2) | w（数组或矩阵），theta（数字[, 轴]） | [ 6.123233995736766e-17, 1] |
| rotationMatrix | 创建给定弧度的 2x2 旋转矩阵。 | rotationMatrix(Math.PI / 2) | theta（数字） | { "mathjs": "DenseMatrix", "data": [ [ 6.123233995736766e-17, -1 ], [ 1, 6.123233995736766e-17 ] ], "size": [ 2, 2 ]} |
| row | 从矩阵中返回指定行。 | row([[1,2],[3,4]], 1) | value（矩阵或数组），index（数字） | [ [ 3, 4 ]] |
| size | 计算矩阵、数组或标量的尺寸（维度）。 | size([[1,2,3],[4,5,6]]) | x（数组、矩阵或数字） | [ 2, 3] |
| sort | 对矩阵或数组进行升序排序。 | sort([3,1,2]) | x（数组或矩阵） | [ 1, 2, 3] |
| sqrtm | 计算方阵的主平方根。 | sqrtm([[4,0],[0,4]]) | A（矩阵或数组） | [ [ 2.000000000000002, 0 ], [ 0, 2.000000000000002 ]] |
| squeeze | 移除矩阵中内部和外部的单一维度。 | squeeze([[[1],[2],[3]]]) | x（矩阵或数组） | [ 1, 2, 3] |
| subset | 获取或替换矩阵或字符串的子集。 | subset([[1, 2], [3, 4]], index(1, 1),2) | x（矩阵、数组或字符串），index（索引），replacement（可选） | [ [ 2, 2 ], [ 3, 4 ]] |
| trace | 计算方阵的迹（对角线元素之和）。 | trace([[1,2],[3,4]]) | x（矩阵或数组） | 5 |
| transpose | 对矩阵进行转置。 | transpose([[1,2],[3,4]]) | x（矩阵或数组） | [ [ 1, 3 ], [ 2, 4 ]] |
| zeros | 创建给定维度的全 0 矩阵。 | zeros(2, 3) | m, n, p...（数字） | { "mathjs": "DenseMatrix", "data": [ [ 0, 0, 0 ], [ 0, 0, 0 ] ], "size": [ 2, 3 ]} |
概率
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| combinations | 计算从 n 个元素中取 k 个无序组合的数量。 | combinations(5, 2) | n（数值），k（数值） | 10 |
| combinationsWithRep | 计算可重复元素的组合数量。 | combinationsWithRep(5, 2) | n（数值），k（数值） | 15 |
| factorial | 计算整数 n 的阶乘。 | factorial(5) | n（整数） | 120 |
| gamma | 使用近似算法计算 gamma 函数值。 | gamma(5) | n（数值） | 24 |
| kldivergence | 计算两个分布的 KL 散度。 | kldivergence([0.1, 0.9], [0.2, 0.8]) | x（数组或矩阵），y（数组或矩阵） | 0.036690014034750584 |
| lgamma | 计算 gamma 函数的对数（扩展近似）。 | lgamma(5) | n（数值） | 3.178053830347945 |
| multinomial | 根据一组计数计算多项式系数。 | multinomial([1, 2, 3]) | a（数组） | 60 |
| permutations | 计算 n 个元素中，取 k 个有序排列的数量。 | permutations(5, 2) | n（数值），k（数值，可选） | 20 |
| pickRandom | 从一维数组中随机选取一个或多个值。 | pickRandom([10, 20, 30]) | 数组 | 20 |
| random | 获取一个均匀分布的随机数。 | random(1, 10) | 最小值（可选），最大值（可选） | 3.6099423753668143 |
| randomInt | 获取一个均匀分布的随机整数。 | randomInt(1, 10) | 最小值（可选），最大值（可选） | 5 |
有理数
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| compare | 比较两个值，可返回 -1、0 或 1。 | compare(2, 3) | x，y（任意类型） | -1 |
| compareNatural | 以自然、可重复的方式比较任意类型的值。 | compareNatural('2', '10') | x，y（任意类型） | -1 |
| compareText | 以字典序方式比较两个字符串。 | compareText('apple', 'banana') | x（字符串），y（字符串） | -1 |
| deepEqual | 逐元素比较两个矩阵/数组是否相同。 | deepEqual([[1, 2]], [[1, 2]]) | x（数组/矩阵），y（数组/矩阵） | true |
| equal | 判断两个值是否相等。 | equal(2, 2) | x，y（任意类型） | true |
| equalText | 判断两个字符串是否相同。 | equalText('hello', 'hello') | x（字符串），y（字符串） | true |
| larger | 判断 x 是否大于 y。 | larger(3, 2) | x，y（数字或大数） | true |
| largerEq | 判断 x 是否大于等于 y。 | largerEq(3, 3) | x，y（数字或大数） | true |
| smaller | 判断 x 是否小于 y。 | smaller(2, 3) | x，y（数字或大数） | true |
| smallerEq | 判断 x 是否小于等于 y。 | smallerEq(2, 2) | x，y（数字或大数） | true |
| unequal | 判断两个值是否不相等。 | unequal(2, 3) | x，y（任意类型） | true |
集合
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| setCartesian | 生成两个（多）集合的笛卡尔积。 | setCartesian([1, 2], [3, 4]) | 第一个集合（数组），第二个集合（数组） | [ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ]] |
| setDifference | 生成两个（多）集合的差集（set1 中有但 set2 中没有的元素）。 | setDifference([1, 2, 3], [2]) | 第一个集合（数组），第二个集合（数组） | [ 1, 3] |
| setDistinct | 获取（多）集合中的唯一元素。 | setDistinct([1, 2, 2, 3]) | 集合（数组） | [ 1, 2, 3] |
| setIntersect | 生成两个（多）集合的交集。 | setIntersect([1, 2], [2, 3]) | 第一个集合（数组），第二个集合（数组） | [ 2] |
| setIsSubset | 判断 set1 是否是 set2 的子集。 | setIsSubset([1, 2], [1, 2, 3]) | 第一个集合（数组），第二个集合（数组） | true |
| setMultiplicity | 统计在多重集合中某个元素出现的次数。 | setMultiplicity(2, [1, 2, 2, 3]) | 元素（任意类型），集合（数组） | 2 |
| setPowerset | 生成一个（多）集合的所有子集，即幂集。 | setPowerset([1, 2]) | 集合（数组） | [ [], [ 1 ], [ 2 ], [ 1, 2 ]] |
| setSize | 统计（多）集合中所有元素的数量。 | setSize([1, 2, 3]) | 集合（数组） | 3 |
| setSymDifference | 生成两个（多）集合的对称差（只在其中一个集合中的元素）。 | setSymDifference([1, 2], [2, 3]) | 第一个集合（数组），第二个集合（数组） | [ 1, 3] |
| setUnion | 生成两个（多）集合的并集。 | setUnion([1, 2], [2, 3]) | 第一个集合（数组），第二个集合（数组） | [ 1, 3, 2] |
特殊
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| erf | 使用有理切比雪夫近似来计算误差函数。 | erf(0.5) | 输入值 x（数字） | 0.5204998778130465 |
统计
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| cumsum | 计算列表或矩阵的累加和。 | cumsum([1, 2, 3, 4]) | [ 1, 3, 6, 10] | |
| mad | 计算数据的中位绝对偏差。 | mad([1, 2, 3, 4]) | 1 | |
| max | 返回列表或矩阵的最大值。 | max([1, 2, 3]) | 3 | |
| mean | 计算平均值。 | mean([2, 4, 6]) | 4 | |
| median | 计算中位数。 | median([1, 2, 3, 4, 5]) | 3 | |
| min | 返回列表或矩阵的最小值。 | min([1, 2, 3]) | 1 | |
| mode | 计算众数（最常出现的值）。 | mode([1, 2, 2, 3]) | [ 2] | |
| prod | 计算列表或矩阵中所有数的乘积。 | prod([1, 2, 3, 4]) | 24 | |
| quantileSeq | 计算列表或矩阵在 prob 位置上的分位数。 | quantileSeq([1, 2, 3, 4], 0.25) | 1.75 | |
| std | 计算数据的标准差。 | std([1, 2, 3, 4]) | 1.2909944487358056 | |
| sum | 计算列表或矩阵所有数的和。 | sum([1, 2, 3]) | 6 | |
| variance | 计算数据的方差。 | variance([1, 2, 3, 4]) | 1.6666666666666667 |
字符串
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| bin | 将数字格式化为二进制。 | bin(13) | 13 | |
| format | 将任意类型的值转为指定精度的字符串。 | format(123.456, 2) | 120 | |
| hex | 将数字格式化为十六进制。 | hex(255) | 255 | |
| oct | 将数字格式化为八进制。 | oct(64) | 64 | |
| 将多个数值插入到字符串模板中。 | print('x = $x, y = $y', {x: 3, y: 4}, 2) | x = 3, y = 4 |
三角函数
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| acos | 计算反余弦值。 | acos(0.5) | 1.0471975511965979 | |
| acosh | 计算双曲反余弦值。 | acosh(2) | 1.3169578969248166 | |
| acot | 计算反余切值。 | acot(1) | 0.7853981633974483 | |
| acoth | 计算双曲反余切值。 | acoth(2) | 0.5493061443340548 | |
| acsc | 计算反余割值。 | acsc(2) | 0.5235987755982989 | |
| acsch | 计算双曲反余割值。 | acsch(2) | 0.48121182505960347 | |
| asec | 计算反正割值。 | asec(2) | 1.0471975511965979 | |
| asech | 计算双曲反正割值。 | asech(0.5) | 1.3169578969248166 | |
| asin | 计算反正弦值。 | asin(0.5) | 0.5235987755982989 | |
| asinh | 计算双曲反正弦值。 | asinh(1.5) | 1.1947632172871094 | |
| atan | 计算反正切值。 | atan(1) | 0.7853981633974483 | |
| atan2 | 计算具有两个参数的反正切值。 | atan2(1, 2) | 0.4636476090008061 | |
| atanh | 计算双曲反正切值。 | atanh(0.5) | 0.5493061443340548 | |
| cos | 计算 x 的余弦值。 | cos(0.5) | 0.8775825618903728 | |
| cosh | 计算 x 的双曲余弦值。 | cosh(0.5) | 1.1276259652063807 | |
| cot | 计算 x 的余切值。 | cot(0.5) | 1.830487721712452 | |
| coth | 计算 x 的双曲余切值。 | coth(0.5) | 2.163953413738653 | |
| csc | 计算 x 的余割值。 | csc(0.5) | 2.085829642933488 | |
| csch | 计算 x 的双曲余割值。 | csch(0.5) | 1.9190347513349437 | |
| sec | 计算 x 的正割值。 | sec(0.5) | 1.139493927324549 | |
| sech | 计算 x 的双曲正割值。 | sech(0.5) | 0.886818883970074 | |
| sin | 计算 x 的正弦值。 | sin(0.5) | 0.479425538604203 | |
| sinh | 计算 x 的双曲正弦值。 | sinh(0.5) | 0.5210953054937474 | |
| tan | 计算 x 的正切值。 | tan(0.5) | 0.5463024898437905 | |
| tanh | 计算 x 的双曲正切值。 | tanh(0.5) | 0.46211715726000974 |
单位
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| to | 将一个数值转换为指定单位。 | to(unit('2 inch'), 'cm') | { "mathjs": "Unit", "value": 5.08, "unit": "cm", "fixcodefix": true} |
通用
| Function | Definition | Example call | Parameters | Expected result |
|---|---|---|---|---|
| clone | 对输入值进行深拷贝。 | clone([1, 2, 3]) | [ 1, 2, 3] | |
| hasNumericValue | 检测输入是否包含数值。 | hasNumericValue('123') | true | |
| isInteger | 检测输入是否是整数。 | isInteger(3.0) | true | |
| isNaN | 检测输入是否为 NaN。 | isNaN(NaN) | true | |
| isNegative | 检测输入是否为负数。 | isNegative(-5) | true | |
| isNumeric | 检测输入是否为数值。 | isNumeric('123') | false | |
| isPositive | 检测输入是否为正数。 | isPositive(2) | true | |
| isPrime | 检测输入是否为质数。 | isPrime(7) | true | |
| isZero | 检测输入是否为 0。 | isZero(0) | true | |
| numeric | 将输入值转换为特定的数值类型（如 number、BigNumber 等）。 | numeric('123') | 123 | |
| typeOf | 返回输入值的类型名称。 | typeOf([1, 2, 3]) | Array |