TinyMath 函数

Elastic Stack Serverless

TinyMath 提供了一组函数，可与 Canvas 表达式语言一起使用以执行复杂的数学计算。继续阅读以获取有关 TinyMath 中可用函数的详细信息，包括每个函数接受的参数、该函数的返回值以及每个函数的行为示例。

大多数函数接受数组并将 JavaScript Math 方法应用于该数组的每个元素。 对于接受多个数组作为参数的函数，该函数通常按索引进行计算。

任何函数都可以被另一个函数包装，只要内部函数的返回类型与外部函数的可接受参数类型匹配即可。

计算数字的绝对值。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的绝对值。 如果 a 是数组，则返回一个包含每个元素的绝对值的数组。

示例

abs(-1)
abs(2)
abs([-1 , -2, 3, -4])

1. 返回 1
2. 返回 2
3. 返回 [1, 2, 3, 4]

计算传入函数的一个或多个数字/数组的总和。如果至少一个数字数组传递到函数中，则该函数将按索引计算总和。

返回: number | Array.<number>。 如果 args 仅包含数字，则返回 args 中所有数字的总和。 如果 args 包含至少一个数组，则返回每个索引处元素总和的数组，包括 args 中每个索引计算中的所有标量数。

抛出: 如果 args 包含长度不同的数组，则抛出 '数组长度不匹配'

示例

add(1, 2, 3)
add([10, 20, 30, 40], 10, 20, 30)
add([1, 2], 3, [4, 5], 6)

1. 返回 6
2. 返回 [70, 80, 90, 100]
3. 返回 [(1 + 3 + 4 + 6), (2 + 3 + 5 + 6)] = [14, 16]

计算数字的立方根。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的立方根。 如果 a 是数组，则返回一个包含每个元素的立方根的数组。

示例

cbrt(-27)
cbrt(94)
cbrt([27, 64, 125])

1. 返回 -3
2. 返回 4.546835943776344
3. 返回 [3, 4, 5]

计算数字的上限，即，将数字四舍五入到正无穷大。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的上限。 如果 a 是数组，则返回一个包含每个元素的上限的数组。

示例

ceil(1.2)
ceil(-1.8)
ceil([1.1, 2.2, 3.3])

1. 返回 2
2. 返回 -1
3. 返回 [2, 3, 4]

将值限制在给定的范围内，并返回可用的封闭值。如果仅提供 min，则值仅限于下限。

返回: number | Array.<number>。 min（含）和 max（含）之间的最接近的值。返回一个数组，其中每个索引处的值大于或等于 min 且小于或等于 max（如果提供）。

抛出:

• 如果 min 和/或 max 是长度不同的数组，则抛出 '数组长度不匹配'
• 如果 max 小于 min，则抛出 '最小值必须小于最大值'

示例

clamp(1, 2, 3)
clamp([10, 20, 30, 40], 15, 25)
clamp(10, [15, 2, 4, 20], 25)
clamp(35, 10, [20, 30, 40, 50])
clamp([1, 9], 3, [4, 5])

1. 返回 2
2. 返回 [15, 20, 25, 25]
3. 返回 [15, 10, 10, 20]
4. 返回 [20, 30, 35, 35]
5. 返回 [clamp([1, 3, 4]), clamp([9, 3, 5])] = [3, 5]

返回数组的长度。大小的别名。

返回: number。 数组的长度。

抛出: 如果 a 不是数组，则抛出 '必须传递一个数组'。

示例

count([])
count([-1, -2, -3, -4])
count(100)

1. 返回 0
2. 返回 4
3. 返回 1

计算数字的立方。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的立方。 如果 a 是数组，则返回一个包含每个元素的立方的数组。

示例

cube(-3)
cube([3, 4, 5])

1. 返回 -27
2. 返回 [27, 64, 125]

将两个数字相除。如果至少一个数字数组传递到函数中，则该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 如果两者都是数字，则返回 a 和 b 的商。 如果 a 或 b 是数组，则返回一个包含应用于每个元素的索引商的数组。

抛出:

• 如果 a 和 b 是长度不同的数组，则抛出 '数组长度不匹配'
• 如果 b 等于 0 或包含 0，则抛出 '不能除以 0'

示例

divide(6, 3)
divide([10, 20, 30, 40], 10)
divide(10, [1, 2, 5, 10])
divide([14, 42, 65, 108], [2, 7, 5, 12])

1. 返回 2
2. 返回 [1, 2, 3, 4]
3. 返回 [10, 5, 2, 1]
4. 返回 [7, 6, 13, 9]

计算 e^x，其中 e 是欧拉数。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 返回一个数组，其中包含求值的 e^x 的值，其中 x 是如果 a 是数组，则为 a 的每个元素。

示例

exp(2)
exp([1, 2, 3])

1. 返回 e^2 = 7.3890560989306495
2. 返回 [e^1, e^2, e^3] = [2.718281828459045, 7.3890560989306495, 20.085536923187668]

返回数组的第一个元素。如果传入的不是数组，则返回输入。

返回: *。 a 的第一个元素。 如果 a 不是数组，则返回 a。

示例

first(2)
first([1, 2, 3])

1. 返回 2
2. 返回 1

计算数字的 fix，即，将数字四舍五入为 0。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的 fix。 如果 a 是数组，则返回包含每个元素的修正的数组。

示例

fix(1.2)
fix(-1.8)
fix([1.8, 2.9, -3.7, -4.6])

1. 返回 1
2. 返回 -1
3. 返回 [1, 2, -3, -4]

计算数字的下限，即，将数字四舍五入到负无穷大。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的下限。 如果 a 是数组，则返回包含每个元素的下限的数组。

示例

floor(1.8)
floor(-1.2)
floor([1.7, 2.8, 3.9])

1. 返回 1
2. 返回 -2
3. 返回 [1, 2, 3]

返回数组的最后一个元素。如果传入的不是数组，则返回输入。

返回: *。 a 的最后一个元素。 如果 a 不是数组，则返回 a。

示例

last(2)
last([1, 2, 3])

1. 返回 2
2. 返回 3

计算数字的对数。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的对数。 如果 a 是数组，则返回一个包含每个元素的对数的数组。

抛出:

• 如果 b ⇐ 0，则抛出 '底数超出范围'
• 如果 a > 0，则抛出 '必须大于 0'

示例

log(1)
log(64, 8)
log(42, 5)
log([2, 4, 8, 16, 32], 2)

1. 返回 0
2. 返回 2
3. 返回 2.322344707681546
4. 返回 [1, 2, 3, 4, 5]

计算以 10 为底的数字的对数。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>。 a 的对数。 返回一个数组，其中包含每个元素的以 10 为底的对数。

抛出: 如果 a < 0，则抛出 '必须大于 0'

示例

log(10)
log(100)
log(80)
log([10, 100, 1000, 10000, 100000])

1. 返回 1
2. 返回 2
3. 返回 1.9030899869919433
4. 返回 [1, 2, 3, 4, 5]

查找传入函数的一个或多个数字/数字数组的最大值。如果至少一个数字数组传递到函数中，则该函数将按索引查找最大值。

返回: number | Array.<number>。 如果 args 仅包含数字，则返回所有数字的最大值。 返回一个数组，其中包含每个索引处的最大值，包括 args 中每个索引计算中的所有标量数。

抛出: 如果 args 包含长度不同的数组，则抛出 '数组长度不匹配'

示例

max(1, 2, 3)
max([10, 20, 30, 40], 15)
max([1, 9], 4, [3, 5])

1. 返回 3
2. 返回 [15, 20, 30, 40]
3. 返回 [max([1, 4, 3]), max([9, 4, 5])] = [4, 9]

查找传入函数的一个或多个数字/数字数组的平均值。如果至少一个数字数组传递到函数中，则该函数将按索引查找平均值。

返回: number | Array.<number>。 如果 args 仅包含数字，则返回所有数字的平均值。 返回一个数组，其中包含每个索引的平均值，包括 args 中每个索引计算中的所有标量数。

示例

mean(1, 2, 3)
mean([10, 20, 30, 40], 20)
mean([1, 9], 5, [3, 4])

1. 返回 2
2. 返回 [15, 20, 25, 30]
3. 返回 [mean([1, 5, 3]), mean([9, 5, 4])] = [3, 6]

查找传入函数中的一个或多个数字/数字数组的中位数。如果至少一个数字数组被传入函数，函数将通过索引查找中位数。

返回: number | Array.<number>. 如果 args 仅包含数字，则返回所有数字的中位数。如果 args 包含至少一个数组，则返回包含每个索引的中位数值的数组，包括每个索引计算中的所有标量数字。

示例

median(1, 1, 2, 3)
median(1, 1, 2, 2, 3)
median([10, 20, 30, 40], 10, 20, 30)
median([1, 9], 2, 4, [3, 5])

1. 返回 1.5
2. 返回 2
3. 返回 [15, 20, 25, 25]
4. 返回 [median([1, 2, 4, 3]), median([9, 2, 4, 5])] = [2.5, 4.5]

查找传入函数中的一个或多个数字/数字数组的最小值。如果至少一个数字数组被传入函数，函数将通过索引查找最小值。

返回: number | Array.<number>. 如果 args 仅包含数字，则返回所有数字的最小值。如果 a 是一个数组，则返回包含每个索引的最小值的数组，包括每个索引计算中的所有标量数字。

抛出: 如果 args 包含不同长度的数组，则抛出 '数组长度不匹配'。

示例

min(1, 2, 3)
min([10, 20, 30, 40], 25)
min([1, 9], 4, [3, 5])

1. 返回 1
2. 返回 [10, 20, 25, 25]
3. 返回 [min([1, 4, 3]), min([9, 4, 5])] = [1, 4]

计算两个数相除后的余数。如果至少一个数字数组被传入函数，函数将按索引方式应用于每个元素。

返回: number | Array.<number>. 如果 a 和 b 都是数字，则返回 a 除以 b 的余数。如果 a 或 b 是一个数组，则返回包含按索引方式应用于每个元素的余数的数组。

抛出:

• 如果 a 和 b 是长度不同的数组，则抛出 '数组长度不匹配'
• 如果 b 等于 0 或包含 0，则抛出 '不能除以 0'

示例

mod(10, 7)
mod([11, 22, 33, 44], 10)
mod(100, [3, 7, 11, 23])
mod([14, 42, 65, 108], [5, 4, 14, 2])

1. 返回 3
2. 返回 [1, 2, 3, 4]
3. 返回 [1, 2, 1, 8]
4. 返回 [5, 2, 9, 0]

查找传入函数中的一个或多个数字/数字数组的众数。如果至少一个数字数组被传入函数，函数将通过索引查找众数。

返回: number | Array.<Array.<number>>. 如果 args 仅包含数字，则返回所有数字的众数值数组。如果 args 包含至少一个数组，则返回包含每个索引的众数值数组的数组，包括每个索引计算中的所有标量数字。

示例

mode(1, 1, 2, 3)
mode(1, 1, 2, 2, 3)
mode([10, 20, 30, 40], 10, 20, 30)
mode([1, 9], 1, 4, [3, 5])

1. 返回 [1]
2. 返回 [1,2]
3. 返回 [[10], [20], [30], [10, 20, 30, 40]]
4. 返回 [mode([1, 1, 4, 3]), mode([9, 1, 4, 5])] = [[1], [4, 5, 9]]

将两个数相乘。如果至少一个数字数组被传入函数，函数将按索引方式应用于每个元素。

返回: number | Array.<number>. 如果 a 和 b 都是数字，则返回 a 和 b 的乘积。如果 a 或 b 是一个数组，则返回包含按索引方式应用于每个元素的乘积的数组。

抛出: 如果 a 和 b 是长度不同的数组，则抛出 '数组长度不匹配'。

示例

multiply(6, 3)
multiply([10, 20, 30, 40], 10)
multiply(10, [1, 2, 5, 10])
multiply([1, 2, 3, 4], [2, 7, 5, 12])

1. 返回 18
2. 返回 [100, 200, 300, 400]
3. 返回 [10, 20, 50, 100]
4. 返回 [2, 14, 15, 48]

计算数字的立方根。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>. a 的 b 次方。如果 a 是一个数组，则返回包含每个元素被提高到 b 次方的数组。

抛出: 如果未提供 b，则抛出 '缺少指数'。

示例

pow(2,3)
pow([1, 2, 3], 4)

1. 返回 8
2. 返回 [1, 16, 81]

在给定的范围内生成一个随机数，其中下限是包含的，上限是不包含的。如果没有传入任何数字，它将返回一个介于 0 和 1 之间的数字。如果只传入一个数字，它将返回一个介于 0 和传入的数字之间的数字。

返回: number. 如果没有传入任何数字，则返回一个介于 0 和 1 之间的随机数。如果只传入一个数字，则返回一个介于 0 和 a 之间的随机数。如果传入两个数字，则返回一个介于 a 和 b 之间的随机数。

抛出: 如果只传入 a 时 a < 0，或者当同时传入 a 和 b 时 a > b，则抛出 '最小值必须大于最大值'

示例

random()
random(10)
random(-10,10)

1. 返回一个介于 0（包含）和 1（不包含）之间的随机数
2. 返回一个介于 0（包含）和 10（不包含）之间的随机数
3. 返回一个介于 -10（包含）和 10（不包含）之间的随机数

查找传入函数中的一个或多个数字/数字数组的范围。如果至少一个数字数组被传入函数，函数将通过索引查找范围。

返回: number | Array.<number>. 如果 args 仅包含数字，则返回所有数字的范围值。返回一个数组，其中包含每个索引的范围值，包括每个索引计算中的所有标量数字（如果 args 包含至少一个数组）。

示例

range(1, 2, 3)
range([10, 20, 30, 40], 15)
range([1, 9], 4, [3, 5])

1. 返回 2
2. 返回 [5, 5, 15, 25]
3. 返回 [range([1, 4, 3]), range([9, 4, 5])] = [3, 5]

查找传入函数中的一个或多个数字/数字数组的范围。如果至少一个数字数组被传入函数，函数将通过索引查找范围。

返回: number | Array.<number>. 如果 args 仅包含数字，则返回所有数字的范围值。返回一个数组，其中包含每个索引的范围值，包括每个索引计算中的所有标量数字（如果 args 包含至少一个数组）。

示例

range(1, 2, 3)
range([10, 20, 30, 40], 15)
range([1, 9], 4, [3, 5])

1. 返回 2
2. 返回 [5, 5, 15, 25]
3. 返回 [range([1, 4, 3]), range([9, 4, 5])] = [3, 5]

默认情况下将数字四舍五入到最接近的整数，或者四舍五入到指定的小数位（如果作为 b 传入）。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>. a 的四舍五入值。如果 a 是一个数组，则返回包含每个元素的四舍五入值的数组。

示例

round(1.2)
round(-10.51)
round(-10.1, 2)
round(10.93745987, 4)
round([2.9234, 5.1234, 3.5234, 4.49234324], 2)

1. 返回 2
2. 返回 -11
3. 返回 -10.1
4. 返回 10.9375
5. 返回 [2.92, 5.12, 3.52, 4.49]

返回数组的长度。count 的别名。

返回: number。 数组的长度。

抛出: 如果 a 不是一个数组，则抛出 '必须传入一个数组'。

示例

size([])
size([-1, -2, -3, -4])
size(100)

1. 返回 0
2. 返回 4
3. 返回 1

计算一个数的平方根。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>. a 的平方根。如果 a 是一个数组，则返回包含每个元素的平方根的数组。

抛出: 如果 a < 0，则抛出 '无法找到负数的平方根'。

示例

sqrt(9)
sqrt(30) //5.477225575051661
sqrt([9, 16, 25])

1. 返回 3
2. 返回 [3, 4, 5]

计算一个数的平方。对于数组，该函数将按索引方式应用于每个元素。

返回: number | Array.<number>. a 的平方。如果 a 是一个数组，则返回包含每个元素的平方的数组。

示例

square(-3)
square([3, 4, 5])

1. 返回 9
2. 返回 [9, 16, 25]

将两个数相减。如果至少一个数字数组被传入函数，函数将按索引方式应用于每个元素。

返回: number | Array.<number>. 如果 a 和 b 都是数字，则返回 a 和 b 的差，或者返回按索引方式应用于每个元素的差的数组。

抛出: 如果 a 和 b 是长度不同的数组，则抛出 '数组长度不匹配'。

示例

subtract(6, 3)
subtract([10, 20, 30, 40], 10)
subtract(10, [1, 2, 5, 10])
subtract([14, 42, 65, 108], [2, 7, 5, 12])

1. 返回 3
2. 返回 [0, 10, 20, 30]
3. 返回 [9, 8, 5, 0]
4. 返回 [12, 35, 52, 96]

计算传入函数中的一个或多个数字/数组的总和。如果至少传入一个数组，函数将对一个或多个数字/数字数组以及数组的不同值进行求和。Sum 接受不同长度的数组。

返回: number. 一个或多个数字/数字数组的总和，包括数组中的不同值

示例

sum(1, 2, 3)
sum([10, 20, 30, 40], 10, 20, 30)
sum([1, 2], 3, [4, 5], 6)
sum([10, 20, 30, 40], 10, [1, 2, 3], 22)

1. 返回 6
2. 返回 160
3. 返回 sum(1, 2, 3, 4, 5, 6) = 21
4. 返回 sum(10, 20, 30, 40, 10, 1, 2, 3, 22) = 138

计算数组中唯一值的数量。

返回: number. 数组中唯一值的数量。如果 a 不是一个数组，则返回 1。

示例

unique(100)
unique([])
unique([1, 2, 3, 4])
unique([1, 2, 3, 4, 2, 2, 2, 3, 4, 2, 4, 5, 2, 1, 4, 2])

1. 返回 1
2. 返回 0
3. 返回 4
4. 返回 5