# TS-SQL / 聚集函数

## `correlOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算两个表达式的相关系数

<!-- tags: TS-SQL 聚集 相关系数 correlation 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 第一个数值表达式，可使用 `DISTINCT` 去重             |
| `expression_2`       | t_expression | 第二个数值表达式                                     |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算两列数据的相关系数

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect correlOf(["Y"], ["X"]) from rows end;
// 输出：0.981155781039212
```

## `covOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算两个表达式的协方差

<!-- tags: TS-SQL 聚集 协方差 covariance 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 第一个数值表达式，可使用 `DISTINCT` 去重             |
| `expression_2`       | t_expression | 第二个数值表达式                                     |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算两列数据的协方差

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect covOf(["Y"], ["X"]) from rows end;
// 输出：2.375
```

## `interceptOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算以第一个表达式为因变量、第二个表达式为自变量的线性回归截距

<!-- tags: TS-SQL 聚集 回归 截距 intercept 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 因变量表达式，可使用 `DISTINCT` 去重                 |
| `expression_2`       | t_expression | 自变量表达式                                         |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算线性回归截距

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect interceptOf(["Y"], ["X"]) from rows end;
// 输出：0
```

## `percentRankOf(expression, x, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算指定值在数值集合中的百分比排位，最小值为 `0`，最大值为 `1`

<!-- tags: TS-SQL 聚集 百分位 排名 排位 percent rank -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 数值表达式，可使用 `DISTINCT` 去重                   |
| `x`                  | real         | 要计算排位的数值                                     |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算数值的百分比排位

```tsl
rows := array(10, 6, 2, 1, 9);
return vselect percentRankOf(thisRow, 2) from rows end;
// 输出：0.25
```

## `rsqOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算两个表达式的乘积矩相关系数平方

<!-- tags: TS-SQL 聚集 回归 判定系数 R平方 rsq 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 第一个数值表达式，可使用 `DISTINCT` 去重             |
| `expression_2`       | t_expression | 第二个数值表达式                                     |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算乘积矩相关系数平方

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect rsqOf(["Y"], ["X"]) from rows end;
// 输出：0.962666666666667
```

## `skewOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的样本偏度，空值不参与统计

<!-- tags: TS-SQL 聚集 偏度 skew 不对称 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 数值表达式，可使用 `DISTINCT` 去重                   |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算样本偏度

```tsl
rows := array(("A": 5), ("A": 5), ("A": 9), ("A": 7));
return vselect skewOf(["A"]) from rows end;
// 输出：0.854563038327971
```

## `slopeAndInterceptOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算线性回归斜率和截距，返回数组依次包含斜率与截距

<!-- tags: TS-SQL 聚集 回归 斜率 截距 slope intercept 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 因变量表达式，可使用 `DISTINCT` 去重                 |
| `expression_2`       | t_expression | 自变量表达式                                         |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：array

### 示例

范例01：计算线性回归斜率和截距

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect slopeAndInterceptOf(["Y"], ["X"]) from rows end;
// 输出：array(1.9,0.0)
```

## `slopeOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算以第一个表达式为因变量、第二个表达式为自变量的线性回归斜率

<!-- tags: TS-SQL 聚集 回归 斜率 slope 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 因变量表达式，可使用 `DISTINCT` 去重                 |
| `expression_2`       | t_expression | 自变量表达式                                         |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算线性回归斜率

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect slopeOf(["Y"], ["X"]) from rows end;
// 输出：1.9
```

## `steyxOf(expression_1, expression_2, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算线性回归预测值的标准误差

<!-- tags: TS-SQL 聚集 回归 标准误差 steyx 双序列 -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression_1`       | t_expression | 因变量表达式，可使用 `DISTINCT` 去重                 |
| `expression_2`       | t_expression | 自变量表达式                                         |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算线性回归标准误差

```tsl
rows := array(
    ("X": 1, "Y": 2),
    ("X": 2, "Y": 4),
    ("X": 3, "Y": 5),
    ("X": 4, "Y": 8)
);
return vselect steyxOf(["Y"], ["X"]) from rows end;
// 输出：0.591607978309961
```

## `checksumOf(expression, ...)`

声明：function

计算当前行一个或多个表达式的校验值，表达式顺序会影响结果

<!-- tags: TS-SQL 校验和 哈希 checksum 行 -->

| 参数         | 类型         | 说明                                                  |
| ------------ | ------------ | ----------------------------------------------------- |
| `expression` | t_expression | 第一个参与校验的表达式，使用 `*` 时包含当前行全部字段 |
| `...`        | t_expression | 可选。继续参与校验的表达式                            |

返回：integer

### 示例

范例01：计算两列组成的行校验值

```tsl
rows := array(("A": 1, "B": 2), ("A": 3, "B": 4));
result := vselect checksumOf(["A"], ["B"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1945464334
```

## `countOf(expression)`

声明：function

统计当前组中表达式的非空值数量，省略表达式时统计全部行

<!-- tags: TS-SQL 聚集 计数 count 数量 -->

| 参数         | 类型         | 说明                                              |
| ------------ | ------------ | ------------------------------------------------- |
| `expression` | t_expression | 可选。要统计的表达式，省略或使用 `*` 时统计全部行 |

返回：integer

### 示例

范例01：统计非空值数量

```tsl
rows := array(
    ("A": 1, "B": 2, "C": 7),
    ("A": nil, "B": 3, "C": 12),
    ("A": 4, "B": 20, "C": 34)
);
result := vselect countOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：2
```

## `refOf(expression, n, bool_condition_exp)`

声明：function

返回当前行之前或之后指定位置的表达式值

<!-- tags: TS-SQL 行引用 上一行 下一行 lag lead reference -->

| 参数                 | 类型         | 说明                                                   |
| -------------------- | ------------ | ------------------------------------------------------ |
| `expression`         | t_expression | 要引用的表达式                                         |
| `n`                  | integer      | 相对当前行的偏移量，正数向前，负数向后，`0` 表示当前行 |
| `bool_condition_exp` | t_expression | 可选。只在条件为真的行中计算相对位置                   |

返回：any

### 示例

范例01：按条件引用前两行的值

```tsl
rows := array(
    ("A": 5, "B": 1, "C": 34),
    ("A": 6, "B": 2, "C": 34),
    ("A": 3, "B": 4, "C": 34),
    ("A": 2, "B": 2, "C": 34),
    ("A": 7, "B": 8, "C": 34),
    ("A": -1, "B": 59, "C": 34),
    ("A": 1, "B": 18, "C": 34),
    ("A": 9, "B": 1, "C": 34),
    ("A": 2, "B": 0, "C": 34),
    ("A": 4, "B": 18, "C": 34)
);
result := select ["A"], refOf(["A"], 2, ["A"] > 2) as "refA" from rows end;
echo trim(toStn(result)), "\n";
// 输出：
// array(
// ("A":5,"refA":0),
// ("A":6,"refA":0),
// ("A":3,"refA":5),
// ("A":2,"refA":6),
// ("A":7,"refA":6),
// ("A":-1,"refA":3),
// ("A":1,"refA":3),
// ("A":9,"refA":3),
// ("A":2,"refA":7),
// ("A":4,"refA":7))
```

## `countIfOf(expression, n, moving_first, cache_id)`

声明：function

统计当前组中表达式为真的行数

<!-- tags: TS-SQL 聚集 条件计数 count if 数量 -->

| 参数           | 类型         | 说明                                                 |
| -------------- | ------------ | ---------------------------------------------------- |
| `expression`   | t_expression | 要统计的布尔表达式                                   |
| `n`            | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first` | bool         | 可选。保留参数，当前不影响统计方式                   |
| `cache_id`     | string       | 可选。时间序列统计缓存标识                           |

返回：integer

### 示例

范例01：统计大于指定值的行数

```tsl
rows := array(
    ("A": 6, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 2, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect countIfOf(["A"] > 4) from rows end;
echo trim(toStn(result)), "\n";
// 输出：4
```

## `avgOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的算术平均值，空值不参与统计

<!-- tags: TS-SQL 聚集 平均值 average mean -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算去重后的算术平均值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect avgOf(distinct ["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：6.0
```

## `emaOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的指数移动平均值，不支持空值

<!-- tags: TS-SQL 聚集 指数移动平均 EMA average -->

| 参数                 | 类型         | 说明                                      |
| -------------------- | ------------ | ----------------------------------------- |
| `expression`         | t_expression | 参与计算的数值表达式                      |
| `bool_condition_exp` | t_expression | 用于筛选参与计算行的布尔表达式            |
| `n`                  | integer      | 指数移动平均周期                          |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件 |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                |

返回：real

### 示例

范例01：计算两期指数移动平均值

```tsl
rows := array(
    ("A": 6, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 2, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := select emaOf(["A"], true, 2) from rows end;
echo trim(toStn(result)), "\n";
// 输出：
// array(
// ("Expr1":6.0),
// ("Expr1":5.33333333333333),
// ("Expr1":7.77777777777778),
// ("Expr1":3.92592592592593),
// ("Expr1":5.97530864197531))
```

## `smaOf(expression, m, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的平滑移动平均值，不支持空值

<!-- tags: TS-SQL 聚集 平滑移动平均 SMA average -->

| 参数                 | 类型         | 说明                                      |
| -------------------- | ------------ | ----------------------------------------- |
| `expression`         | t_expression | 参与计算的数值表达式                      |
| `m`                  | integer      | 平滑权重参数                              |
| `bool_condition_exp` | t_expression | 用于筛选参与计算行的布尔表达式            |
| `n`                  | integer      | 平滑移动平均周期                          |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件 |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                |

返回：real

### 示例

范例01：计算三期平滑移动平均值

```tsl
rows := array(
    ("A": 6, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 2, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := select smaOf(["A"], 2, true, 3) from rows end;
echo trim(toStn(result)), "\n";
// 输出：
// array(
// ("Expr1":6.0),
// ("Expr1":5.33333333333333),
// ("Expr1":7.77777777777778),
// ("Expr1":3.92592592592593),
// ("Expr1":5.97530864197531))
```

## `harMeanOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的调和平均值，空值不参与统计

<!-- tags: TS-SQL 聚集 调和平均 harmonic mean -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算去重后的调和平均值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect harMeanOf(distinct ["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：5.83333333333333
```

## `geoMeanOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的几何平均值，空值不参与统计

<!-- tags: TS-SQL 聚集 几何平均 geometric mean -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算去重后的几何平均值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect geoMeanOf(distinct ["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：5.91607978309962
```

## `sumOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的总和，空值不参与统计

<!-- tags: TS-SQL 聚集 求和 sum total -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算去重后的总和

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect sumOf(distinct ["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：12.0
```

## `minOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式的最小值

<!-- tags: TS-SQL 聚集 最小值 minimum min -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：返回满足条件的最小值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect minOf(["A"], ["A"] > 6) from rows end;
echo trim(toStn(result)), "\n";
// 输出：7.0
```

## `maxOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式的最大值

<!-- tags: TS-SQL 聚集 最大值 maximum max -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：返回满足条件的最大值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect maxOf(["A"], ["A"] > 6) from rows end;
echo trim(toStn(result)), "\n";
// 输出：9.0
```

## `refMinOf(expression, id_string)`

声明：function

返回 `minOf` 最小值所在行的另一个表达式值

<!-- tags: TS-SQL 聚集 最小值 行引用 argmin reference -->

| 参数         | 类型         | 说明                              |
| ------------ | ------------ | --------------------------------- |
| `expression` | t_expression | 要从最小值所在行读取的表达式      |
| `id_string`  | string       | 可选。对应 `minOf` 使用的缓存标识 |

返回：any

### 示例

范例01：读取两列最小值所在行的关联值

```tsl
rows := array(
    ("A": 6, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 2, "C": 34),
    ("A": 2, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := select
    minOf(["A"], true, nil, true, "<MAXMIN=minA/>"),
    minOf(["B"], true, nil, true, "<MAXMIN=minB/>"),
    refMinOf(["B"], "minA"),
    refMinOf(["A"], "minB")
from rows end;
echo trim(toStn(result)), "\n";
// 输出：
// array(
// ("Expr1":2.0,"Expr2":2.0,"Expr3":20,"Expr4":9))
```

## `refMaxOf(expression, id_string)`

声明：function

返回 `maxOf` 最大值所在行的另一个表达式值

<!-- tags: TS-SQL 聚集 最大值 行引用 argmax reference -->

| 参数         | 类型         | 说明                              |
| ------------ | ------------ | --------------------------------- |
| `expression` | t_expression | 要从最大值所在行读取的表达式      |
| `id_string`  | string       | 可选。对应 `maxOf` 使用的缓存标识 |

返回：any

### 示例

范例01：读取两列最大值所在行的关联值

```tsl
rows := array(
    ("A": 6, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 2, "C": 34),
    ("A": 2, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := select
    maxOf(["A"], true, nil, true, "<MAXMIN=maxA/>"),
    maxOf(["B"], true, nil, true, "<MAXMIN=maxB/>"),
    refMaxOf(["B"], "maxA"),
    refMaxOf(["A"], "maxB")
from rows end;
echo trim(toStn(result)), "\n";
// 输出：
// array(
// ("Expr1":9.0,"Expr2":20.0,"Expr3":2,"Expr4":6))
```

## `modeOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式中出现频率最高的值

<!-- tags: TS-SQL 聚集 众数 mode -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算众数

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect modeOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：5.0
```

## `medianOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式的中位数，偶数个值时返回中间两值的平均值

<!-- tags: TS-SQL 聚集 中位数 median -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算中位数

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect medianOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：6.0
```

## `stdevOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的样本标准差，空值不参与统计

<!-- tags: TS-SQL 聚集 样本标准差 standard deviation -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算样本标准差

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect stdevOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1.91485421551268
```

## `stdevpOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的总体标准差，空值不参与统计

<!-- tags: TS-SQL 聚集 总体标准差 population standard deviation -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算总体标准差

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect stdevpOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1.6583123951777
```

## `varOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的样本方差，空值不参与统计

<!-- tags: TS-SQL 聚集 样本方差 variance -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算样本方差

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect varOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：3.66666666666667
```

## `varpOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式的总体方差，空值不参与统计

<!-- tags: TS-SQL 聚集 总体方差 population variance -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算总体方差

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect varpOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：2.75
```

## `totalVarOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式各值与均值之差的平方和

<!-- tags: TS-SQL 聚集 总方差 平方和 total variance -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算总方差

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect totalVarOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：11.0
```

## `aveDevOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式各值与均值之差的绝对值平均数

<!-- tags: TS-SQL 聚集 平均绝对偏差 average deviation -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算平均绝对偏差

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect aveDevOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1.5
```

## `devSqOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式各值与均值之差的平方和

<!-- tags: TS-SQL 聚集 偏差平方和 deviation square -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算偏差平方和

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect devSqOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：11.0
```

## `normOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式平方和的平方根

<!-- tags: TS-SQL 聚集 范数 平方和 norm -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算二范数

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect normOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：13.4164078649987
```

## `skew2Of(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算与矩阵算法兼容的总体偏度

<!-- tags: TS-SQL 聚集 总体偏度 skewness -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算总体偏度

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect skew2Of(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：0.493382200218159
```

## `kurtosisOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算与表格算法兼容的总体峰度

<!-- tags: TS-SQL 聚集 峰度 kurtosis -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算表格算法峰度

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect kurtosisOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：-1.28925619834711
```

## `kurtosis2Of(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算与矩阵算法兼容的总体峰度

<!-- tags: TS-SQL 聚集 峰度 kurtosis matrix -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算矩阵算法峰度

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect kurtosis2Of(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1.62809917355372
```

## `largeOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式中第 `k` 个最大值

<!-- tags: TS-SQL 聚集 第K大 top kth maximum -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与排序的数值表达式                                 |
| `k`                  | integer      | 从大到小的序号，从 `1` 开始                          |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：返回第二大值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect largeOf(["A"], 2) from rows end;
echo trim(toStn(result)), "\n";
// 输出：7.0
```

## `smallOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式中第 `k` 个最小值

<!-- tags: TS-SQL 聚集 第K小 bottom kth minimum -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与排序的数值表达式                                 |
| `k`                  | integer      | 从小到大的序号，从 `1` 开始                          |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：返回第二小值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect smallOf(["A"], 2) from rows end;
echo trim(toStn(result)), "\n";
// 输出：5.0
```

## `percentileOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式指定百分位位置的值

<!-- tags: TS-SQL 聚集 百分位 percentile quantile -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与计算的数值表达式                                 |
| `k`                  | real         | 百分位位置，取值范围为 `0` 到 `1`                    |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算三分之一分位值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect percentileOf(["A"], 1 / 3) from rows end;
echo trim(toStn(result)), "\n";
// 输出：5.0
```

## `quartileOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回数值表达式指定四分位位置的值

<!-- tags: TS-SQL 聚集 四分位 quartile quantile -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与计算的数值表达式                                 |
| `k`                  | integer      | 四分位位置，取值为 `0` 到 `4`                        |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：返回最小四分位值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect quartileOf(["A"], 0) from rows end;
echo trim(toStn(result)), "\n";
// 输出：5.0
```

## `rankOf(expression, x, bool_condition_exp, n, moving_first, cache_id)`

声明：function

返回指定数值在表达式结果中按从大到小排列的名次

<!-- tags: TS-SQL 聚集 排名 排位 rank descending -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与排序的数值表达式                                 |
| `x`                  | real         | 要计算排位的数值                                     |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算指定值的降序名次

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect rankOf(["A"], 7) from rows end;
echo trim(toStn(result)), "\n";
// 输出：2
```

## `trimMeanOf(expression, k, bool_condition_exp, n, moving_first, cache_id)`

声明：function

从数值表达式两端剔除指定比例的数据后计算平均值

<!-- tags: TS-SQL 聚集 截尾平均 trim mean robust -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与计算的数值表达式                                 |
| `k`                  | real         | 从首尾剔除的数据比例                                 |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算截尾平均值

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect trimMeanOf(["A"], 0.2) from rows end;
echo trim(toStn(result)), "\n";
// 输出：6.5
```

## `frequencyOf(expression, calc_array, bool_condition_exp, n, moving_first, cache_id)`

声明：function

统计数值表达式落入各区间的频数

<!-- tags: TS-SQL 聚集 频数 分箱 histogram frequency -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与分组的数值表达式                                 |
| `calc_array`         | array        | 按升序给出的区间上界数组                             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：array

### 示例

范例01：按一个区间上界统计频数

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect frequencyOf(["A"], array(6)) from rows end;
echo trim(toStn(result)), "\n";
// 输出：array(2,2)
```

## `productOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式中全部值的乘积

<!-- tags: TS-SQL 聚集 累乘 乘积 product -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：real

### 示例

范例01：计算全部值的乘积

```tsl
rows := array(
    ("A": 5, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect productOf(["A"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1575.0
```

## `checksum_aggOf(expression, bool_condition_exp, n, moving_first, cache_id)`

声明：function

计算数值表达式全部值的聚集校验和

<!-- tags: TS-SQL 聚集 校验和 checksum hash -->

| 参数                 | 类型         | 说明                                                 |
| -------------------- | ------------ | ---------------------------------------------------- |
| `expression`         | t_expression | 参与统计的表达式，可使用 `DISTINCT` 去重             |
| `bool_condition_exp` | t_expression | 可选。只统计条件为真的行                             |
| `n`                  | integer      | 可选。相对当前行参与统计的记录数，负数表示向后取记录 |
| `moving_first`       | bool         | 可选。是否先限定最近 `n` 条记录再应用条件            |
| `cache_id`           | string       | 可选。时间序列统计缓存标识                           |

返回：integer

### 示例

范例01：计算一列的聚集校验和

```tsl
rows := array(
    ("A": 6, "B": 20, "C": 34),
    ("A": 5, "B": 20, "C": 34),
    ("A": 9, "B": 2, "C": 34),
    ("A": 2, "B": 20, "C": 34),
    ("A": 7, "B": 18, "C": 34)
);
result := vselect checksum_aggOf(["C"]) from rows end;
echo trim(toStn(result)), "\n";
// 输出：1849359852
```