TinyMath functions

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 包含长度不同的数组，则为 'Array length mismatch'

示例

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 是不同长度的数组，则为 'Array length mismatch'
• 如果 max 小于 min，则为 'Min must be less than max'

示例

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]

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

返回: number. 数组的长度。

抛出: 如果 a 不是数组，则为 'Must pass an array'。

示例

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 是不同长度的数组，则为 'Array length mismatch'
• 如果 b 等于 0 或包含 0，则为 'Cannot divide by 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>. 如果 a 是一个数组，则返回一个数组，其中包含 a 的每个元素求得的 e^x 值。

示例

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 的数组。

示例

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

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

计算数字的 floor（向下取整），即向负无穷方向取整。对于数组，该函数将按索引应用于每个元素。

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

示例

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，则为 'Base out of range'
• 如果 a > 0，则为 'Must be greater than 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 的对数。如果 a 是一个数组，则返回一个包含每个元素以 10 为底的对数的数组。

如果 a < 0，则 **抛出**: 'Must be greater than 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 中的所有标量数字包含在每个索引处的计算中。

抛出: 如果 args 包含长度不同的数组，则为 'Array length mismatch'

示例

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 至少包含一个数组，则返回一个数组，其中包含每个索引处的平均值，并将 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 至少包含一个数组，则返回一个数组，其中包含每个索引处的，并将 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 中的所有标量数字包含在每个索引处的计算中。

如果 args 包含长度不同的数组，则 **抛出**: 'Array length mismatch'。

示例

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 是不同长度的数组，则为 'Array length mismatch'
• 如果 b 等于 0 或包含 0，则为 'Cannot divide by 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 至少包含一个数组，则返回一个数组的数组，其中包含每个索引处的众数值，并将 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 是不同长度的数组，则 **抛出**: 'Array length mismatch'

示例

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，则 **抛出**: 'Missing exponent'

示例

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，则 **抛出**: 'Min must be greater than max'

示例

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

1. 返回 0（含）到 1（不含）之间的随机数
2. 返回 0（含）到 10（不含）之间的随机数
3. 返回 -10（含）到 10（不含）之间的随机数

查找传递到函数中的一个或多个数字/数字数组的范围。如果至少传递了一个数字数组，该函数将按索引查找范围。

返回: number | Array.<number>. 如果 args 只包含数字，则返回所有数字的范围值。如果 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 至少包含一个数组，则返回一个数组，其中包含每个索引处的范围值，并将 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 不是数组，则 **抛出**: 'Must pass an array'

示例

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

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

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

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

如果 a < 0，则 **抛出**: 'Unable find the square root of a negative number'

示例

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 是不同长度的数组，则 **抛出**: 'Array length mismatch'

示例

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