1552 lines
56 KiB
Markdown
1552 lines
56 KiB
Markdown
# 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
|
|
```
|