csh/playbook
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
476f99913956d972c91cb38c5af4a4f1c0aa4eb5
playbook/skills/tsl-api-reference/references/codegen/dotnet/base/array.md
T

4380 lines
126 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 基础函数 / 数组
## `arrDropDuplicate(data)`
声明：function
数组去重（包含 NAN）；仅保留用于识别旧代码
<!-- tags: 数组 列表 array list 去重 删除重复 deduplicate duplicate dropduplicate NAN -->
| 参数 | 类型 | 说明 |
| ------ | ----- | -------------------- |
| `data` | array | 数据表类型。数据表。 |
返回：array
### 示例
```tsl
t := array(("A":1, "B":NAN), ("A":1, "B":2), ("A":1, "B":NAN), ("A":1, "B":2));
return arrDropDuplicate(t);
// 输出：array(("A":1,"B":NAN),("A":1,"B":2))
```
## `descartesJoin(v_1, v_2, ...)`
声明：function
计算多个值或数组的笛卡尔积
<!-- tags: 数组 笛卡尔积 组合 连接 array cartesian product -->
| 参数 | 类型 | 说明 |
| ----- | ---- | ------------------ |
| `v_1` | any | 第一个值或数组 |
| `v_2` | any | 第二个值或数组 |
| `...` | any | 可选。更多值或数组 |
返回：array
### 示例
范例01：连接三个输入值
```tsl
return descartesJoin(1->3, 21->22, 3);
// 输出：
// array(
// (1,21,3),
// (1,22,3),
// (2,21,3),
// (2,22,3),
// (3,21,3),
// (3,22,3))
```
## `framemerge(left, right, ons, how, suffixes, if_multi_field, keep_method)`
声明：function
按指定字段连接两个数据表
<!-- tags: 数组 数据表 联结 合并 join merge table -->
| 参数 | 类型 | 说明 |
| ---------------- | --------------- | -------------------------------------------- |
| `left` | table | 左表 |
| `right` | table | 右表 |
| `ons` | string\|array | 连接字段或左右表连接字段数组 |
| `how` | string\|integer | 可选。连接方式，默认 `inner` |
| `suffixes` | array | 可选。重名字段后缀，默认 `array('_x', '_y')` |
| `if_multi_field` | boolean | 可选。是否按多个共同字段连接，默认 false |
| `keep_method` | integer | 可选。重名字段保留方式，默认 0 |
返回：array
### 示例
范例01：按 id 执行内连接
```tsl
left := `array('id': (1, 2), 'left_value': (10, 20));
right := `array('id': (2, 3), 'right_value': (30, 40));
return framemerge(
left, right, 'id', 'inner', array('_x', '_y'), false, 0);
// 输出：array(("id_x":2,"left_value":20,"id_y":2,"right_value":30))
```
## `frameupdate(left, right, ons, type)`
声明：function
按键字段用右表补充或更新左表中的缺失值，并直接修改左表
<!-- tags: 数组 数据表 更新 缺失值 merge update table -->
| 参数 | 类型 | 说明 |
| ------- | ------------- | ------------------------------- |
| `left` | table | 待更新的左表 |
| `right` | table | 提供更新值的右表 |
| `ons` | string\|array | 可选。键字段，省略时按下标连接 |
| `type` | integer | 可选。缺失值类型位掩码，默认 15 |
返回：array
### 示例
范例01：用右表填充左表缺失值
```tsl
left := `array('id': (1, 2), 'value': (nil, 20));
right := `array('id': (1, 2), 'value': (10, 30));
return frameupdate(left, right, 'id', 15);
// 输出：
// array(
// ("id":1,"value":10),
// ("id":2,"value":20))
```
## `getSubTableByField(t, fields)`
声明：function
按字段名称提取数据表的指定列
<!-- tags: 数组 数据表 字段 列 提取 查询 select column -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------- |
| `t` | array | 数据表 |
| `fields` | string | 字段名称，多个名称用分号分隔 |
返回：array
### 示例
范例01：提取 name 和 price 两列
```tsl
value := array(
("name": "A", "price": 1, "amount": 10),
("name": "B", "price": 2, "amount": 20));
return getSubTableByField(value, "name;price");
// 输出：
// array(
// ("name":"A","price":1),
// ("name":"B","price":2))
```
## `renameFieldByFormat(t, suffix, if_copy)`
声明：function
按格式字符串批量修改数据表字段名
<!-- tags: 数组 数据表 字段 重命名 格式 rename column -->
| 参数 | 类型 | 说明 |
| --------- | ------- | --------------------------------- |
| `t` | array | 待处理数据表 |
| `suffix` | string | 格式字符串，`%s` 表示原字段名 |
| `if_copy` | boolean | 可选。是否在副本上修改，默认 true |
返回：array
### 示例
范例01：为全部字段添加后缀
```tsl
value := array(("a": 1, "b": 2));
return renameFieldByFormat(value, "%s_x", true);
// 输出：array(("a_x":1,"b_x":2))
```
## `speye(m)`
声明：function
创建指定阶数的稀疏单位矩阵
<!-- tags: 数组 稀疏矩阵 单位矩阵 sparse identity matrix -->
| 参数 | 类型 | 说明 |
| ---- | ------- | -------- |
| `m` | integer | 矩阵阶数 |
返回：array
### 示例
范例01：创建三阶稀疏单位矩阵
```tsl
return speye(3);
// 输出：
// array(
// (1),
// (1:1),
// (2:1))
```
## `tableType(t)`
声明：function
判断数组的数据表下标类型
<!-- tags: 数组 数据表 类型 下标 table type -->
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `t` | array | 待判断数组 |
不是数组时返回 `-1`，字符串下标数组返回 `0`，数字下标数组返回 `1`
返回：integer
### 示例
范例01：判断数字下标二维数组
```tsl
return tableType(array((1, 2), (3, 4)));
// 输出：1
```
## `webFormatToRung(a, type, zero_eps)`
声明：function
将数组中的 nan、nil、正负无穷和接近零的数值替换为短横线
<!-- tags: 数组 缺失值 格式化 nan nil inf web -->
| 参数 | 类型 | 说明 |
| ---------- | ------- | ------------------------------------- |
| `a` | array | 待处理数组 |
| `type` | integer | 可选。替换类型位掩码，默认 15 |
| `zero_eps` | real | 可选。接近零的判断阈值，默认 `epsi()` |
返回：any
### 示例
范例01：替换 nil 和 nan
```tsl
value := array(nil, nan, 1);
return webFormatToRung(value, 15, 1e-10);
// 输出：array("-","-",1)
```
## `abnormalData(y, flag, ystore)`
声明：function
数组中出现奇异值的处理。其中y为数据表，Flag为处理方法，Ystore为选择中位数和3倍标准差法返回被处理数据的数据
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------------ |
| `y` | array | 一维数字数组 |
| `flag` | string | 用户自定义，奇异值处理方法 |
| `ystore` | array | 数据表类型，存放修改的数据，包括修改的行、原数值、处理后的值 |
返回：any
### 示例
示例：返回奇异值的位置及处理后的结果。
```tsl
t := array(1, 100, 101, 102, 103, 1000);
abnormalData(t, "median", r);
return r;
// 输出：
// 其中，0和5为修改的行，1和1000是对应的原值，93.7和109.3是修改后的值
```
## `appendArray(arr, con)`
声明：function
数组新增元素，给数组arr添加一项con
<!-- tags: 添加 追加 -->
| 参数 | 类型 | 说明 |
| ----- | ------- | ------------------------ |
| `arr` | array | 一维数组 |
| `con` | integer | 整数或字符串，需增加的值 |
返回：array
### 示例
```tsl
a := array(1, 2, 3);
appendArray(a, 4);
return a;
// 输出：
```
## `argconfirst(a, v, _type)`
声明：function
第一次满足条件的位置, 原数组必须为有序表且元素应可比较
| 参数 | 类型 | 说明 |
| ------- | ------------------- | -------- |
| `a` | array | 有序数组 |
| `v` | string\|real\|array | 对比值 |
| `_type` | integer | 对比条件 |
返回：integer
### 示例
范例1：实数对比
```tsl
a := 0->9;
return argconfirst(a, 3.5, 1); // 输出：4
```
范例2：数组对比
```tsl
a := array(("a", "A"), ("b", "B"), ("c", "C"), ("d", "D"));
v := array("b", "B");
return argconfirst(a, v, 6); // 输出：1
```
## `argmax(x)`
声明：function
1、返回一维数组中最大值所在下标
<!-- tags: 数组 列表 array list 最大值 最大 maximum max 下标 索引 位置 index -->
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ------------ |
| `x` | array,tablearray | 一维数字数组 |
返回：integer
### 示例
```tsl
x := array(9, 8, 10);
return argmax(x);
// 输出：2
```
## `argmin(x)`
声明：function
1、返回一维数组中最小值所在下标
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ------------ |
| `x` | array,tablearray | 一维数字数组 |
返回：integer
### 示例
```tsl
x := array(3, 1, 9, 2);
return argmin(x); // 输出：1
```
## `argsort(value, sortdir)`
声明：function
返回可以用于排序的一维数组下标
<!-- tags: 排序 sort 返回 获取 -->
| 参数 | 类型 | 说明 |
| --------- | ------- | --------------------------------------- |
| `value` | array | 一维数字数组，数组 |
| `sortdir` | integer | 整数，排序方向（1:正序【默认】;0:逆序） |
返回：array
### 示例
```tsl
value := array(4, 8, 2, 3, 9);
return argsort(value); // 输出：array(2,3,0,1,4)
```
## `arrayAddGap(t, key, v, m)`
声明：function
数组添加分割线,只支持字符串下标
| 参数 | 类型 | 说明 |
| ----- | ------- | ------------------------------------------- |
| `t` | array | 数组，待添加数组，直接在原数组更改 |
| `key` | string | 字符串，间隔名，默认无 |
| `v` | string | 字符串，间隔串，默认为 DupeString('-',m\*2) |
| `m` | integer | 整型，间隔串的长度设置，默认 5 |
返回：array
### 示例
```tsl
a := array('alpha(%)': 3);
arrayAddGap(a, '风险');
a['beta'] := 3;
return a; // 输出：array("alpha(%)":3,"-----风险-----":"----------","beta":3)
```
## `arrayextend(a, ind, v)`
声明：function
数组-指定位置插入子集
| 参数 | 类型 | 说明 |
| ----- | --------------- | ---------------------------- |
| `a` | array of number | Array of number,一维数字数组 |
| `ind` | integer | Integer,插入的起始位置 |
| `v` | array of number | Array of number,插入的子数组 |
返回：array
### 示例
```tsl
a := letters(1->6);
return arrayextend(a, 2, array('d', 'e'));
// 输出：array("A", "B", "d", "e", "C", "D", "E", "F")
```
## `arraygetdefault(r, k, v)`
声明：function
带默认值的数组取值，取指定下标的值，若存在则返回，否则返回设定的默认值
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `r` | array of string | Array of string, |
| `k` | string | String,下标 |
| `v` | string | String,默认值 |
返回：any
### 示例
```tsl
r := array("a": 1, "b": 2);
return arraygetdefault(r, "x", 99); // 下标 x 不存在，返回默认值 99；若取 "a" 则返回 1
// 输出：99
```
## `arrayinsert(a, ind, v)`
声明：function
数组-指定位置插入值
| 参数 | 类型 | 说明 |
| ----- | --------------- | ---------------------------- |
| `a` | array of number | Array of number,一维数字数组 |
| `ind` | integer | Integer,插入位置 |
| `v` | any | Any,元素值 |
返回：array
### 示例
```tsl
a := letters(1->6);
return arrayinsert(a, 2, 3);
// 输出：array("A", "B", 3, "C", "D", "E", "F")
```
## `arraysetdefault(r, k, v)`
声明：function
带默认值的数组赋值(字段未使用则赋值)
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `r` | array of string | Array of string, |
| `k` | string | String,下标 |
| `v` | string | String,默认值 |
返回：bool
### 示例
```tsl
r := array("a": 1, "b": 2);
arraysetdefault(r, "x", 99); // 下标 x 未使用，赋值 99 并返回 true；若对已存在的 "a" 调用则不改、返回 false
return r;
// 输出：array("a":1,"b":2,"x":99)
```
## `arraysetdefault2(r, k, v)`
声明：function
带默认值的数组赋值(值为nil则赋值)
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `r` | array of string | Array of string, |
| `k` | string | String,下标 |
| `v` | string | String,默认值 |
返回：bool
### 示例
```tsl
r := array("a": 1, "b": nil);
arraysetdefault2(r, "b", 99); // b 的值为 nil，赋值 99 并返回 true；下标缺失时同样赋值
return r;
// 输出：array("a":1,"b":99)
```
## `aveDevByColumn(t, f_name)`
声明：function
指定列与平均值的绝对偏差的平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return aveDevByColumn(t2, 'c');
// 输出：12.5
```
## `averageByColumn(t, f_name)`
声明：function
求指定列的平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return averageByColumn(t1, 'b');
// 输出：6
```
## `averageValueByColumn(t, f_name, from_row, to_row)`
声明：function
求在指定多行中指定列的平均值
| 参数 | 类型 | 说明 |
| ---------- | ------- | --------------------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
| `from_row` | integer | 计算起始行索引号（从0开始） |
| `to_row` | integer | 计算结束行索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return averageValueByColumn(t2, 'c', 1, 3);
// 输出：43
```
## `columnValue(t, fname)`
声明：function
获取指定列的所有值(按列名)。该函数的功能与直接用读取子矩阵的方式一样，但是用子矩阵的方式更简单快速。功能相当于t[:,fname]
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `fname` | string | 字符串，列字段名称 |
返回：any
### 示例
```tsl
s := select ['StockID'] as '代码',
["StockName"] as "名称",
['price'] as '收盘'
from markettable datekey 20190101T to 20190201T of 'SZ000001' end;
return columnValue(s, '收盘');
// 输出：
```
## `columnValue2(t, column_name)`
声明：function
获取多个指定列的所有记录
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------------ |
| `t` | array | 数据表，二维数组 |
| `column_name` | string | 指定多个字段，以分号分割 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'b': 2, 'c': 13), ('a': 3, 'c': 33, 'b': 3), ('a': 3, 'b': 6, 'c': 43), ('a': 5, 'c': 53, 'b': 5));
return columnValue2(t2, 'a;c');
```
## `compareDataOfDifferentDataProvider(t_src, t_dest, src_provider, dest_provider, key_arr, value_arr, code_field)`
声明：function
比较两个数据源的差异
| 参数 | 类型 | 说明 |
| --------------- | ------ | ------------------------------------------------------ |
| `t_src` | array | Array 源数据 |
| `t_dest` | array | Array 目标数据 |
| `src_provider` | string | String 源数据提供商 |
| `dest_provider` | string | String 目标数据提供商 |
| `key_arr` | array | Array 要比较表的Key字段（也就是数据表中的 唯一性字段） |
| `value_arr` | array | Array 要比较的Value字段 |
| `code_field` | string | String 代码字段（任何数据，都必须有编码字段） |
返回：array
### 示例
```tsl
src := array(("code": "A", "value": 1));
dest := array(("code": "A", "value": 1));
result := compareDataOfDifferentDataProvider(
src,
dest,
"source",
"target",
array("code"),
array("value"),
"code"
);
echo trim(toStn(result));
```
## `DataProcess_MF(arr, fwm)`
声明：function
极值处理(多因子),对数据表以列为单位处理奇异值。其中arr为数据表，fwm为处理方法
| 参数 | 类型 | 说明 |
| ----- | ------ | -------------------- |
| `arr` | array | 数据表类型 |
| `fwm` | string | 用户自定义，处理方法 |
返回：any
### 示例
```tsl
data := array(array(1, 100, 101, 102, 103, 1000), array(2, 200, 201, 202, 203, 2000));
echo trim(toStn(DataProcess_MF(data, "median")));
```
## `deleteColumnByField(t, fields)`
声明：function
删除指定列，可以一次性删除多列，删除的列字段之间使用；分割
<!-- tags: 删除 移除 -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------------------------ |
| `t` | array | 指定数组，数据表列名为字符串类型，程序执行完后会变更为删除指定列后的数组 |
| `fields` | string | 指定列，字符串 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return deleteColumnByField(t1, 'a;b');
```
## `deleteNilValueByField(t, fields)`
声明：function
删除指定字段fields数据为NIL的记录
<!-- tags: 删除 移除 NIL -->
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------- |
| `t` | array | 数据表类型，数据 |
| `fields` | string | 字符串，字段名称，多个字段用分号（;）连接，例:＂Field1;Field2＂ |
返回：array
### 示例
```tsl
tdata := array(array('time': 1, 'price': 7.78), array('time': 2));
deleteNilValueByField(tdata, 'price');
return tdata;
// 输出：
// array(
// ("time":1,"price":7.78))
```
## `describe(data, percentiles)`
声明：function
简单描述统计
| 参数 | 类型 | 说明 |
| ------------- | --------------- | ---------------------------------------------------- |
| `data` | array of number | 一维数字数组,或 二维矩阵。二维矩阵时，对每列进行操作 |
| `percentiles` | array of number | 统计的分位点，默认取array(0.25,0.5, 0.75) |
返回：array
### 示例
范例01:
```tsl
load_dataset_iris(data);
return describe(data);
```
范例02:
```tsl
return describe(randn(0, 1, 1000), array(0.05, 0.1)->0.95);
```
## `devsqByColumn(t, f_name)`
声明：function
指定列平均值偏差的平方和
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return devsqByColumn(t1, 'b');
// 输出：0.5
```
## `distinctStr(t)`
声明：function
去掉序列中的重复元素
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------- |
| `t` | array | 一维字符串/数字数组 |
返回：array
### 示例
```tsl
a := array('w', 'd', 'f', 'd', 'e');
return distinctStr(a); // 保留不相同的，相同的只保留一个
```
## `dumies_decode(dumiesdata)`
声明：function
虚拟变量矩阵解构，根据所给的虚拟变量矩阵返回分类变量结果
| 参数 | 类型 | 说明 |
| ------------ | ----- | -------------------------- |
| `dumiesdata` | array | 二维数字数组，虚拟变量矩阵 |
返回：array
### 示例
```tsl
data := array(
("real_estate": 1, "metal": 0, "bank": 0),
("real_estate": 0, "metal": 1, "bank": 0),
("real_estate": 0, "metal": 0, "bank": 1)
);
echo trim(toStn(dumies_decode(data)));
```
## `elementWhere(con, x, y)`
声明：function
根据布尔数组con,为True时从X中，为False时从Y中，取对应位置元素的值
| 参数 | 类型 | 说明 |
| ----- | ---------------- | ---- |
| `con` | array,tablearray | |
| `x` | array,tablearray | |
| `y` | array,tablearray | |
返回：array,tablearray
### 示例
```tsl
con := array(1, 0, 1, 1, 1, 0);
x := array(1, 2, 3, 4, 5, 6);
y := array(11, 12, 13, 14, 15, 16);
return elementWhere(con, x, y); // 输出：array(1,12,3,4,5,16)
```
## `expandTable(t, key_field)`
声明：function
按指定字段展开表格，根据Keyfield展开指定列。展开的列值必须二维数据表，否则保留原值
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------------------- |
| `t` | array | 数组类型，数据 |
| `key_field` | string | 字符串类型，关键字，需展开的列名 |
返回：array
### 示例
```tsl
// 按照分红送股列展开数据：分红送股列本身是子表，展开为多行
data := array(
("代码":"SH600000", "名称":"浦发银行", "分红送股":array(("年度":2019, "派息":6), ("年度":2020, "派息":8))),
("代码":"SZ000002", "名称":"万科A", "分红送股":array(("年度":2020, "派息":12))));
return expandTable(data, "分红送股");
// 输出：
// array(
// ("代码":"SH600000","名称":"浦发银行","分红送股":2019),
// ("分红送股":6),
// ("分红送股":2020),
// ("分红送股":8),
// ("代码":"SZ000002","名称":"万科A","分红送股":2020),
// ("分红送股":12))
```
## `factorize(value, ifsort, nan_fill_value, uniques)`
声明：function
分类变量数值映射，将一个一维分类变量数组映射为给分类变量递增编号后的数值数组
<!-- tags: 排序 sort -->
| 参数 | 类型 | 说明 |
| ---------------- | ----- | ---------------------------------- |
| `value` | array | 数组，一维数组 |
| `ifsort` | bool | 布尔型，是否排序，默认不排序 |
| `nan_fill_value` | any | 数字/字符串，填充nan的值，默认为-1 |
| `uniques` | array | 数组，输出，各值对应的原值 |
返回：array
### 示例
```tsl
value := Array('a', 'd', 'c', 'a', 'b');
labels := factorize(value, true, -1, uniques);
echo uniques; // array("a","b","c","d")
return labels; // 输出：array(0,3,2,0,1);
```
## `Field_AddPrefix(t, prefix, ifcopy)`
声明：function
数组下标批量加前缀
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------------- |
| `t` | array | 数组类型，数据 |
| `prefix` | string | 字符串类型，前缀 |
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddPrefix(data, "pre_", true)));
```
## `Field_AddSuffix(t, suffix, ifcopy)`
声明：function
数组下标批量加后缀
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------------- |
| `t` | array | 数组类型，数据 |
| `suffix` | string | 字符串类型，后缀 |
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddSuffix(data, "_new", true)));
```
## `Field_ReSortCols(data, cols_showpriority)`
声明：function
数组下标按指定顺序重排 ps：不检查字段是否存在
<!-- tags: 排序 sort -->
| 参数 | 类型 | 说明 |
| ------------------- | ----- | --------------------------------- |
| `data` | array | 二维数字数组,数组，目前只支持二维 |
| `cols_showpriority` | array | 一维字符串数组,字段显示优先级 |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1, "date": 20250101));
priority := array("value": 100, "date": -1);
echo trim(toStn(Field_ReSortCols(data, priority)));
```
## `fieldCount(t)`
声明：function
数据表字段个数。如果t不是一个数据表，则返回0
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldCount(t1);
// 输出：2
```
## `fieldCountOfStrSubscript(t)`
声明：function
字符串下标数组的字段个数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `t` | array | 数据表类型 |
返回：integer
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return fieldCountOfStrSubscript(s);
// 输出：4
```
## `fieldExist(t, f_name)`
声明：function
指定字段是否存在。如果存在，则返回索引号；(索引号从0开始)，不存在，返回－1
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定字段，字符串 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldExist(t1, 'b');
// 输出：1
```
## `fieldName(t, field_index)`
声明：function
返回数据表指定列索引号（索引号从0开始）的字段名称
<!-- tags: 返回 获取 -->
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------ |
| `t` | array | 数据表 |
| `field_index` | integer | 指定列，整数 |
返回：string
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldName(t1, 0);
// 输出：a
```
## `fieldNames(t)`
声明：function
返回数据表所有字段名称
<!-- tags: 返回 获取 -->
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));return fieldNames(t1);
```
## `fieldNamesOfStrSubscript(t)`
声明：function
字符串下标数组的字段名称
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `t` | array | 整数 |
返回：any
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return fieldNamesOfStrSubscript(s);
// 输出：
```
## `filterIntersectionPart(t1, t2, f_name, method)`
声明：function
求两个数组在指定列名上的差集、交集、并集
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------------------------------------------- |
| `t1` | array | 数据表 |
| `t2` | array | 数据表 |
| `f_name` | string | 指定列名字符串 |
| `method` | string | 方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 10, 'c': 13), ('a': 2, 'b': 17, 'c': 13));
t2 := array(('a': 2, 'b': 22, 'c': 23), ('a': 1, 'b': 14, 'c': 13), ('a': 3, 'b': 12, 'c': 13));
return filterIntersectionPart(t1, t2, 'a', 'IN'); // t1 与 t2 在列 a 上的交集
// 输出：返回 t1 中 a 值出现在 t2 中的行
// array(
// ("a":1,"b":10,"c":13),
// ("a":2,"b":17,"c":13))
// method='NOT IN' 时返回 t1 中 a 值不在 t2 的行(此例为空 array())；
// method='ALL' 时返回并集(此例为 t2 的三行，a=2,1,3)。
```
## `filterIntersectionPart2(t1, t2, method)`
声明：function
求两个数组的差集、交集、并集。只适用一维数组
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------------------------------------------- |
| `t1` | array | 一维数据表 |
| `t2` | array | 一维数据表 |
| `method` | string | 方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串 |
返回：array
### 示例
```tsl
t1 := array(1, 2, 3, 4);
t2 := array(3, 4, 5, 6);
return filterIntersectionPart2(t1, t2, 'IN'); // t1 与 t2 的交集
// 输出：array(3,4)
// method='NOT IN' 返回 t1 中不在 t2 的元素 array(1,2)；
// method='ALL' 返回并集 array(3,4,5,6,1,2)。
```
## `filterOneDimEx(t, method, v1, v2)`
声明：function
范围取值（一维数组）从一个一维数组中按照取值范围返回对应的记录
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------------------------- |
| `t` | array | 数据表 |
| `method` | string | ’>’，’<’，’<>’，’<=’，’>=’，’IN’，’IN2’，’IN3’ |
| `v1` | real | 实数 |
| `v2` | real | 实数 |
返回：array
### 示例
```tsl
t := array(1, 2, 12, 3.7, 14);
return filterOneDimEx(t, 'IN', 2, 7);
```
## `filterOneDimEx2(t, v1)`
声明：function
小于等于指定值的最后一条记录(一维数组)
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `t` | array | 一维数字数组 |
| `v1` | real | 实数，指定值 |
返回：real
### 示例
```tsl
s := array(1, 2, 3, 4, 5, 6);
return filterOneDimEx2(s, 4);
// 输出：4
```
## `filterTable(t, v)`
声明：function
从指标表中取以下列的值为v的数据
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------ |
| `t` | array | 数组类型，数据 |
| `v` | integer | 报告期类型，报告期 |
返回：array
### 示例
```tsl
// 'SZ002664'在20211231时的分红送股数据
setSysParam(pn_stock(), 'SZ002664');
return filterTable(infoArray(18), 20211231);
```
## `filterTableEx(t, fname, method, v1, v2)`
声明：function
范围取值，从一个表中按照某个字段的取值范围返回对应的记录
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------------------------- |
| `t` | array | 数据表 |
| `fname` | string | 指定字段名，字符串 |
| `method` | string | ’>’，’<’，’<>’，’<=’，’>=’，’IN’，’IN2’，’IN3’ |
| `v1` | real | 实数 |
| `v2` | real | 实数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
return filterTableEx(t2, 'c', 'IN', 13, 30); // 取13<=[ 'c']<=30
```
## `footerAverage(t, from_col, tocol, average_col_field)`
声明：function
调用FooterValue对数组指定列求算术平均
| 参数 | 类型 | 说明 |
| ------------------- | ------- | -------------------------- |
| `t` | array | 数据表类型，数据表 |
| `from_col` | integer | :整数，起始序号 |
| `tocol` | integer | 整数，截止序号 |
| `average_col_field` | string | 字符串，显示“平均”的列字段 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerAverage(s, 1, 3, '');
// 输出：
```
## `footerSum(t, from_col, tocol, average_col_field)`
声明：function
调用FooterValue对数组指定列求算术和
| 参数 | 类型 | 说明 |
| ------------------- | ------- | -------------------------- |
| `t` | array | 数据表类型，数据表 |
| `from_col` | integer | :整数，起始序号 |
| `tocol` | integer | 整数，截止序号 |
| `average_col_field` | string | 字符串，显示“平均”的列字段 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerAverage(s, 1, 3, '');
// 输出：
```
## `footerValue(t, from_col, tocol, average_col_field, _type)`
声明：function
数组t从Fromcol列到ToCol列对每列求算术平均或者累计求和
| 参数 | 类型 | 说明 |
| ------------------- | ------- | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `from_col` | integer | :整数，起始序号 |
| `tocol` | integer | 整数，截止序号 |
| `average_col_field` | string | 字符串，列名 |
| `_type` | any | 用户自定义 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerValue(s, 1, 3, '', 1);
// 输出：
```
## `Frame_addprefix(t, prefix, ifcopy)`
声明：function
数据表-数组下标批量加前缀 二维数组，对列名加前缀 一维数组，对行下标加前缀
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------- |
| `t` | any | Table,源数组 |
| `prefix` | string | String,前缀 |
| `ifcopy` | bool | Bool,是否在拷贝后的数组改列名,默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addprefix(data, "pre_", true)));
```
## `Frame_addsuffix(t, suffix, ifcopy)`
声明：function
数据表-数组下标批量加后缀 二维数组，对列名加后缀 一维数组，对行下标加后缀
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------- |
| `t` | any | Table,源数组 |
| `suffix` | string | String,后缀 |
| `ifcopy` | bool | Bool,是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addsuffix(data, "_new", true)));
```
## `frameconcat(arrdic, _type)`
声明：function
数据表-拼接
| 参数 | 类型 | 说明 |
| -------- | --------- | --------------------------------------------------------------- |
| `arrdic` | array | Array of number,数组的数组,需要拼接的数组集合 |
| `_type` | Usrdefine | Usrdefine,数组拼接方式，默认为0行并=0；列并=1；非完全矩阵列并=2 |
返回：array
### 示例
```tsl
a := ones(3, 3);
b := ones(2, 3);
frameconcat(array(a, b));
```
## `framecorrel(data)`
声明：function
数据表-相关系数矩阵
| 参数 | 类型 | 说明 |
| ------ | ----- | ----------------------------------------------- |
| `data` | table | Table,二维数据表，列名可为字符串,不支持一维数组 |
返回：array
### 示例
```tsl
arr := array(
("沪深300":-0.16, "中证500":-0.46, "中证1000":-0.72, "国债指数":0.06),
("沪深300":2.4, "中证500":2.38, "中证1000":2.77, "国债指数":0.02),
("沪深300":0.61, "中证500":1.84, "中证1000":2.14, "国债指数":0.03),
("沪深300":-0.22, "中证500":-0.26, "中证1000":-0.2, "国债指数":0.05),
("沪深300":1.01, "中证500":0.27, "中证1000":0.21, "国债指数":-0.0),
("沪深300":-0.19, "中证500":-0.16, "中证1000":-0.27, "国债指数":-0.02),
("沪深300":0.72, "中证500":0.77, "中证1000":0.85, "国债指数":0.0),
("沪深300":-0.87, "中证500":-0.66, "中证1000":-0.59, "国债指数":0.02),
("沪深300":1.96, "中证500":1.42, "中证1000":1.09, "国债指数":0.01),
("沪深300":0.02, "中证500":-0.24, "中证1000":-0.15, "国债指数":0.11));
return frameCorrel(arr);
```
## `framecov(data)`
声明：function
数据表-协方差
| 参数 | 类型 | 说明 |
| ------ | ----- | ------------------------------------------------ |
| `data` | table | Table,二维数据表，列名可为字符串。不支持一维数组 |
返回：array
### 示例
```tsl
arr := array(
("沪深300":-0.16, "中证500":-0.46, "中证1000":-0.72, "国债指数":0.06),
("沪深300":2.4, "中证500":2.38, "中证1000":2.77, "国债指数":0.02),
("沪深300":0.61, "中证500":1.84, "中证1000":2.14, "国债指数":0.03),
("沪深300":-0.22, "中证500":-0.26, "中证1000":-0.2, "国债指数":0.05),
("沪深300":1.01, "中证500":0.27, "中证1000":0.21, "国债指数":-0.0),
("沪深300":-0.19, "中证500":-0.16, "中证1000":-0.27, "国债指数":-0.02),
("沪深300":0.72, "中证500":0.77, "中证1000":0.85, "国债指数":0.0),
("沪深300":-0.87, "中证500":-0.66, "中证1000":-0.59, "国债指数":0.02),
("沪深300":1.96, "中证500":1.42, "中证1000":1.09, "国债指数":0.01),
("沪深300":0.02, "中证500":-0.24, "中证1000":-0.15, "国债指数":0.11));
return framecov(arr);
```
## `framecut(a, bins, option, o_lables)`
声明：function
从小到大分段分组，最小的为第0组
| 参数 | 类型 | 说明 |
| ---------- | ------- | --------------------------------------------------------------------------- |
| `a` | array | 数据表或一维数字数组，数据表时，表示对每列分别操作 |
| `bins` | array | 一维数字数组，分段节点，例如array(0,1)将数组a分为[-inf,0)[0,1)[1,inf)三段， |
| `option` | integer | 整型，区间开/闭，默认为0 |
| `o_lables` | integer | 数组，输出分组区间说明 |
返回：array
### 示例
范例01：插入一个字符串
```tsl
a := array(0, 59, 60, 70, 80, 99, 100);
bins := array(60, 80);
return framecut(a, bins, 0);
// array(0,0,1,1,2,2,2)
```
范例2
```tsl
a := array(0, 59, 60, 70, 80, 99, 100);
bins := 5;
return framecut(a, bins, 0);
// array(0,2,3,3,4,4,4)
```
## `Framedrop_duplicates(data, subset, keep, rowname)`
声明：function
数据表-去重
<!-- tags: 去重 删除重复 deduplicate -->
| 参数 | 类型 | 说明 |
| --------- | ------ | --------------------------------------------------- |
| `data` | array | Table,二维数据表,源数据 |
| `subset` | string | String,去重字段 |
| `keep` | string | String,去重保留方法，""f"":保留首个，""l"":保留最后 |
| `rowname` | string | String,保留原索引重置字段名 |
返回：array
### 示例
```tsl
data := array(
("code": "A", "value": 1),
("code": "A", "value": 2),
("code": "B", "value": 3)
);
echo trim(toStn(Framedrop_duplicates(data, "code", "f", "source_index")));
```
## `Framedrop_na(data, how, subset)`
声明：function
数据表-去掉含Nan的行
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------ |
| `data` | array | Table,二维数据表,源数据 |
| `how` | string | String,去na行方法，默认/1/""any"":任意，2/""all"":所有 |
| `subset` | string | String,去重字段 |
返回：array
### 示例
```tsl
data := array((nan, 8), (1, 3));
echo trim(toStn(Framedrop_na(data, "any", array(0))));
```
## `frameGetSubByReg(data, reg)`
声明：function
通过正则表达式匹配获取数据框子集
| 参数 | 类型 | 说明 |
| ------ | ------ | -------------------------- |
| `data` | array | 数组，待匹配的数组 |
| `reg` | string | 字符串，间隔名，正则匹配串 |
返回：array
### 示例
```tsl
t := array((13: 1, "V1": 1, "V2": 11, 12: 21, 'R1w': 1),
(13: 0, "V1": 2, "V2": 12, 12: 22, 'R1w': 1),
(13: 1, "V1": 3, "V2": 13, 12: 23, 'R1w': 1),
(13: 0, "V1": 4, "V2": 14, 12: 24, 'R1w': 1),
(13: 1, "V1": 5, "V2": 15, 12: 25, 'R1w': 1),
(13: 0, "V1": 6, "V2": 16, 12: 26, 'R1w': 1));
return frameGetSubByReg(t, '1');
// 输出：
// array(
// (21, 1, "V1": 1, "R1w": 1),
// (22, 0, "V1": 2, "R1w": 1),
// (23, 1, "V1": 3, "R1w": 1),
// (24, 0, "V1": 4, "R1w": 1),
// (25, 1, "V1": 5, "R1w": 1),
// (26, 0, "V1": 6, "R1w": 1))
```
## `framehhi(data)`
声明：function
数据表-HHI指数、赫芬达尔—赫希曼指数
<!-- tags: HHI -->
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------- |
| `data` | table | Table,数组 |
返回：array
### 示例
```tsl
data := array(0.4, 0.3, 0.2, 0.1);
return framehhi(data); // HHI = 0.4^2+0.3^2+0.2^2+0.1^2
// 输出：0.3
```
## `frameIndex_filter(rawkeys, filter_cond, filter_type, dz_valuetokey)`
声明：function
数组筛选器，用于下标数组行名或列名的筛选器
<!-- tags: 过滤 筛选 filter -->
| 参数 | 类型 | 说明 |
| --------------- | ------ | ---------------------------------------- |
| `rawkeys` | array | 一维字符串数组,下标数组(0开始的自增下标) |
| `filter_cond` | string | 字符串,筛选条件 |
| `filter_type` | any | 用户自定义,筛选类型 |
| `dz_valuetokey` | any | 整数,Out:类型1时，输出ivalue对照用 |
返回：array
### 示例
```tsl
columns := array("name", "period", "factor", "IC@mean", "IC@ratio");
echo trim(toStn(frameIndex_filter(columns, array("period", "factor"), 1)));
```
## `frameIndex_getilocDZ(raw_data_cols)`
声明：function
用于方便获取 下标值 与 字段位置 下标数组对照（下标值->下标位置）
| 参数 | 类型 | 说明 |
| --------------- | ----- | ---------------------------------------- |
| `raw_data_cols` | array | 一维字符串数组,下标数组(从0开始自增数组) |
返回：array
### 示例
```tsl
echo trim(toStn(frameIndex_getilocDZ(array("growth", "value", "momentum"))));
```
## `frameinsert(data, loc, fname, v)`
声明：function
数据表-指定位置插入列
| 参数 | 类型 | 说明 |
| ------- | ------- | ----------------------- |
| `data` | table | Table,二维数据表,源数据 |
| `loc` | integer | Integer,插入位置 |
| `fname` | string | String,插入索引命名 |
| `v` | integer | Integer,插入值 |
返回：array
### 示例
```tsl
data := array(
("SepalLength":4.6, "SepalWidth":3.1),
("SepalLength":5.0, "SepalWidth":3.6),
("SepalLength":5.4, "SepalWidth":3.9));
return frameinsert(data, 1, '新列', 0);
// 输出：
// array(
// ("SepalLength":4.6,"新列":0,"SepalWidth":3.1),
// ("SepalLength":5.0,"新列":0,"SepalWidth":3.6),
// ("SepalLength":5.4,"新列":0,"SepalWidth":3.9))
```
## `Framelag_zf(t, period, fillzero)`
声明：function
数据表-推移涨幅(%) 涨幅(%)算法： period>0: 前n期涨幅 r\[i\] := (t(i)/t(i-period)-1)\*100; period<0: 到未来n期涨幅 r\[i\] := (t(i-period)/t(i)-1)\*100; 注意period>0时，与framePct_change的结果一致
| 参数 | 类型 | 说明 |
| ---------- | ----- | --------------------------------------- |
| `t` | array | Array of number,数据表，支持一维和二维 |
| `period` | any | Integer,移动期数，默认1 |
| `fillzero` | bool | Bool,下标越界是，是否返回0.False返回inf |
返回：array
### 示例
```tsl
echo trim(toStn(Framelag_zf(array(10, 5, 8, 2), 1, false)));
```
## `frameMelt(t, id_names, value_names, variable_sname, value_sname)`
声明：function
二维表——>立体表
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ------------------------------------------------------------------- |
| `t` | array | 二维字符串数组，数据表 |
| `id_names` | array | 一维字符串数组，键字段 |
| `value_names` | array | 一维字符串数组，值字段。为nil或者空时，表每行除开键字段外都是值字段 |
| `variable_sname` | string | 字符串，变量展示名 |
| `value_sname` | string | 字符串，值展示名 |
返回：array
### 示例
```tsl
t := array(
('截止日': 20210101, 'SH000300': 1, 'SH000301': 3),
('截止日': 20210102, 'SH000300': 9, 'SH000301': 2),
);
id_names := array('截止日');
return frameMelt(t, '截止日', nil, '代码', '得分');
```
## `Framepct_change(t, period, fillzero)`
声明：function
数据表-到当期的变动百分比(%) 变动百分比(%)算法 r\[i\] := (t(i)/t(i-period)-1)\*100
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------------------- |
| `t` | array | Array of number,数据表，支持一维和二维 |
| `period` | any | Integer,变动期数，默认1 |
| `fillzero` | bool | Bool,下标越界是，是否返回0. False返回inf |
返回：array
### 示例
```tsl
echo trim(toStn(Framepct_change(array(10, 5, 8, 2), 1, false)));
```
## `framePivot_table(t, index, columns, vals, aggfunc, aggfuncnames)`
声明：function
分组、透视、汇总，类似可见Pivot_table
| 参数 | 类型 | 说明 |
| -------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `t` | any | 数据表类型,数据表 |
| `index` | string | 字符串,行分类字段，字段值含有nill等不可设为索引 |
| `columns` | array | 一维字符串数组,列分类字段，字段值含有nill等不可设为索引 |
| `vals` | array | 一维字符串数组,值字段，未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 |
| `aggfunc` | string | 字符串,值汇总函数,支持如下:；a、所有 TS_SQL 聚合函数:e.g:"avg"(avgof),"sum"(sumof)；b、内置函数:；"\_details": 分组详情；"\_first": 第一个；"\_last": 最后一个；c、自定义函数中使用关键字thisgroup 得到当前分组数据。 |
| `aggfuncnames` | array | 一维字符串数组,自定义汇总函数名称对照表 |
返回：array
### 示例
```tsl
data := array(
("group": "A", "date": "2025-01-01", "value": 1),
("group": "A", "date": "2025-01-02", "value": 2),
("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(framePivot_table(
data,
"group",
array("date"),
array("value"),
"sum",
nil
)));
```
## `frameqcut(data, q)`
声明：function
数据表-按频率分组(等频分组)
| 参数 | 类型 | 说明 |
| ------ | ------- | -------------------------------------------- |
| `data` | table | Table,数据表或一维数字数组，数据表时，表示对 |
| `q` | integer | Integer,分组数，等分q组，正整数，默认q=5 |
返回：array
### 示例
```tsl
data := array(1, 2, 3, 4, 5, 6, 7, 8, 9);
return frameqcut(data, 3); // 按大小等频分为 3 组，返回各元素所属组号(0,1,2)
// 输出：array(0,0,0,1,1,1,2,2,2)
```
## `framevaluecounts(data, countfieldname, iforder)`
声明：function
数据表-计数
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ------------------------------------ |
| `data` | table | Table,可以为二维数据表或者为一维数组 |
| `countfieldname` | string | String,计数字段名，默认为""个数"" |
| `iforder` | bool | Bool,是否排序，默认为真 |
返回：array
### 示例
```tsl
data := array("a", "b", "a", "c", "a", "b");
return framevaluecounts(data, "个数", true); // 统计各值出现次数，按次数降序
// 输出：
// array(
// ("值":"a","个数":3),
// ("值":"b","个数":2),
// ("值":"c","个数":1))
```
## `geoMeanByColumn(t, f_name)`
声明：function
指定列的几何平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return geoMeanByColumn(t1, 'b');
// 输出：4.47
```
## `get_dummies(a, uniques)`
声明：function
1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、如果a中含Nan值，排到uniques的末尾
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| --------- | ----- | ----------------------------------------- |
| `a` | array | 一维数组，指定的分类变量 |
| `uniques` | array | 一维数组，中间结果:输出各列对应的分类变量 |
返回：array
### 示例
```tsl
data := array("A", "B", "C", "A");
encoded := get_dummies(data, categories);
echo trim(toStn(array("categories": categories, "encoded": encoded)));
```
## `get_dummies2(a)`
声明：function
1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、a中的元素必须都可以做为数组下标，否则请使用get_dummies
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------ |
| `a` | array | 一维数组，指定的分类变量 |
返回：array
### 示例
```tsl
echo trim(toStn(get_dummies2(array("A", "A", "B", "C"))));
```
## `getBottomN(t, n)`
声明：function
取数组后N行，一般先用SortByField排序，然后使用此函数
<!-- tags: 排序 sort 获取 查询 -->
| 参数 | 类型 | 说明 |
| ---- | ------- | ------ |
| `t` | array | 数据表 |
| `n` | integer | 整数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getBottomN(t2, 2);
```
## `getDistinctValue(t, f_name)`
声明：function
获取指定列唯一值，返回值为一维数组
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return getDistinctValue(t2, 'a');
```
## `getMiddleN(t, from_no, to_no)`
声明：function
取数组指定行区间记录，一般先用SortByField排序，然后使用此函数
<!-- tags: 排序 sort 获取 查询 -->
| 参数 | 类型 | 说明 |
| --------- | ------- | ---------------------- |
| `t` | array | 数据表 |
| `from_no` | integer | 起始行数:整数，从1开始 |
| `to_no` | integer | 截止行数:整数，从1开始 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 4, 'c': 33), ('a': 5, 'c': 33));
return getMiddleN(t2, 2, 3);
```
## `getSubField(t, field)`
声明：function
获取取表中某一字段的全部列值
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------- |
| `t` | array | 二维数组 |
| `field` | string | 列标名，字符串/整数 |
返回：array
### 示例
```tsl
a := array(('a': 8, 'b': 7), ('a': 6, 'b': 9));
return getSubField(a, 'a'); // 从 a 表中取第 'a' 列
```
## `getSubTable(table, field_arr)`
声明：function
将一个表类型数组只保留指定的字段并返回
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------- |
| `table` | array | 二维数组 |
| `field_arr` | array | 列标名，一维数组 |
返回：array
### 示例
```tsl
a := array((1, 2, 4), (11, 12, 14));
b := array(0, 2);
return getSubTable(a, b);
```
## `getSubTableByKey(t, key_field, return_fields)`
声明：function
将字符串KeyField以分号分隔,在数组t中从列ReturnFields匹配被分割的值,若找到则返回该行信息，否则返回空数组
<!-- tags: 获取 查询 -->
| 参数 | 类型 | 说明 |
| --------------- | ------ | ------------------------ |
| `t` | array | 数据表类型，数据表 |
| `key_field` | string | 字符串，关键字字段 |
| `return_fields` | string | 字符串，要返回的字段名称 |
返回：array
### 示例
```tsl
s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
array('A': 'c', 'B': 3, 'C': 4, 'D': 5, 'e': 6),
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7));
return getSubTableByKey(s, 'A', 'a;c');
// 输出：
```
## `getSubTableFreeParam()`
声明：function
取子表，系统第二个到最个一个参数为字段序列，取第一个参数中字段与字段序列匹配的列数据
<!-- tags: 获取 查询 -->
返回：array
### 示例
```tsl
return getSubTableFreeParam(); // 之前在系统参数中已经设置好第一个参数 s=array(array('s':1,'w':2,'sl':3), array('s':2,'w':3,'sl':4), array('s':3,'w':4,'sl':5))，第二、三个参数为 's'、'w'。
// 输出：
```
## `getTopN(t, n)`
声明：function
取数组前N行记录，一般先用SortByField排序，然后使用此函数
<!-- tags: 排序 sort 获取 查询 -->
| 参数 | 类型 | 说明 |
| ---- | ------- | ------ |
| `t` | array | 数据表 |
| `n` | integer | 整数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getTopN(t2, 2);
```
## `getValuesByFieldValue(t, f_name, field_value)`
声明：function
返回指定字段值等于指定值的所有记录
<!-- tags: 返回 获取 -->
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------- |
| `t` | array | 二维数组 |
| `f_name` | string | 字符串，指定字段 |
| `field_value` | string | 整数/字符串，指定值 |
返回：array
### 示例
```tsl
t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return getValuesByFieldValue(t, 'b', 4); // 返回 'b' 列值为 4 的所有记录
```
## `groupByFieldValue(t, group_field, lowvalue, high_value, sep_value)`
声明：function
按字段大小进行汇总。小于最小值Lowvalue为一组，从最小值Lowvalue到最大值HighValue中间每步长SepValue为一组，大于最大值High为一组
| 参数 | 类型 | 说明 |
| ------------- | ------ | -------------- |
| `t` | array | 数据表类型 |
| `group_field` | string | 字符串，列名 |
| `lowvalue` | real | 实数，最小数值 |
| `high_value` | real | 实数，最大数值 |
| `sep_value` | real | 实数，统计间距 |
返回：any
### 示例
```tsl
data := select * from tradetable datekey 20180903t to 20180904T of 'sz000001' end;
return groupByFieldValue(data, 'close', 1, 20, 0.1);
// 输出：
```
## `groupDemeanIt(t, g_name, v_name)`
声明：function
1、分组去均值，对数据表t按[GName]分组后，对每组的[VName]去均值
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------ |
| `t` | dbdata | 数据表，待分组去均值数据 |
| `g_name` | string | 字符串，t的分组字段名 |
| `v_name` | string | 字符串，去均值字段名 |
返回：array
### 示例
范例1：
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupDemeanIt(t, 'G', 'V1'); // 输出：array(-2.0,-2.0,0.0,0.0,2.0,2.0)
```
范例2
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupDemeanIt(t, 'G', array('V1', 'V2'));
// 输出：
// array(
// ("V1":-2.0,"V2":-2.0),
// ("V1":-2.0,"V2":-2.0),
// ("V1":0.0,"V2":0.0),
// ("V1":0.0,"V2":0.0),
// ("V1":2.0,"V2":2.0),
// ("V1":2.0,"V2":2.0))
```
## `groupPercentrankIt(t, g_name, v_name)`
声明：function
计算分组百分位，对数据表t按[GName]分组后，对每组的[Vname_]计算百分位
<!-- tags: 计算 求解 -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------ |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串，转换字段名 |
返回：array
### 示例
```tsl
t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupPercentrankIt(t, 'G', 'V1'); // 输出：array(0.0,0.0,0.5,0.5,1.0,1.0)
```
## `groupRankIt(t, g_name, v_name, sort_order)`
声明：function
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]计算排名
<!-- tags: 排序 sort 计算 求解 -->
| 参数 | 类型 | 说明 |
| ------------ | ------ | ------------------ |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串，转换字段名 |
| `sort_order` | bool | 布尔型，排名方向 |
返回：array
### 示例
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupRankIt(t, 'G', 'V1'); // 输出：array(1,1,2,2,3,3)
```
## `groupTransformByFunc(t, g_name, v_name, fp)`
声明：function
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]根据给定函数进行分组转换操作
<!-- tags: 计算 求解 -->
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------------------------------------------- |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串或数组，转换字段名 |
| `fp` | string | 字符串（函数名）或函数指针，转换函数必须两个参数，分别表示当前的聚合字段与排名字段，以分组排名为例: |
返回：array
### 示例
范例01：使用自定义函数对分组数据进行转换
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
fp := function(v, g)
begin
return rankof([v], [v]);
end;
return groupTransformByFunc(t, 'G', 'V1', fp);
// 输出：array(3,3,2,2,1,1)
```
## `groupZscoreIt(t, g_name, v_name)`
声明：function
1.计算分组标准化，对数据表t按[GName]分组后，对每组的[Vname_]进行标准化(原值-分组平均)/分组标准差
<!-- tags: 计算 求解 -->
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串，转换字段名。如果Vname*为nil则表示除GName之外的所有字段，如果Vname*为一个数组，则表示需要计算的字段组返回:二维数组， |
返回：array
### 示例
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupZscoreIt(t, 'G', 'V1'); // 输出：array(-1.0,-1.0,0.0,0.0,1.0,1.0)
```
## `harMeanByColumn(t, f_name)`
声明：function
指定列的调和平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return harMeanByColumn(t1, 'b');
// 输出：4.44
```
## `histogram(t, bins, format)`
声明：function
统计data的频数分布表
| 参数 | 类型 | 说明 |
| -------- | ---------------- | --------------------------------------- |
| `t` | array,tablearray | 数字数组，待计算的数组 |
| `bins` | array,tablearray | 数组，表分组间隔 |
| `format` | string | 字符串，展示区间的格式串，见FormatFloat |
返回：array,tablearray
### 示例
范例一：
```tsl
return histogram(Randn(0, 1, 1000), array(-3, 0.5)->3, '0.00');
// 输出：频数分布表。区间列(<=-3.00、-3.00~-2.50 …… 2.50~3.00、>3.00)与区间中位数列固定，
// 但因 Randn 生成的是随机正态样本，各区间的频数、频率(%)、累计频率(%)每次运行都不同。
```
范例二：
```tsl
data := randn(0, 1, 1000, array('a', 'b'));
return histogram(data, array(-3, 0.5)->3, '0.00');
// 输出：多列频数分布表。data 为两列(a、b)随机正态样本，结果按列给出 a@频数、a@频率(%)、
// a@累计频率(%)、b@频数 …… 等列。区间划分固定，但各频数因随机样本每次运行都不同。
```
## `ifsparse(s)`
声明：function
判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数
<!-- tags: 判断 检查 -->
| 参数 | 类型 | 说明 |
| ---- | ------------- | ---------- |
| `s` | array of real | 待判断矩阵 |
返回：integer
### 示例
```tsl
// 判断矩阵S是否为稀疏矩阵
s := Array(3: 2, "B": 3);
return ifsparse(s); // 返回0
```
## `in1(v, x)`
声明：function
判断数值x是否在数组v中，返回布尔类型
<!-- tags: 判断 检查 -->
| 参数 | 类型 | 说明 |
| ---- | ----- | -------- |
| `v` | array | 一维数组 |
| `x` | real | 实数 |
返回：bool
### 示例
```tsl
a := array(1, 2, 3, 4);
return in1(a, 3);
// 输出：1
```
## `inserttablebyrno(t, index, rdata)`
声明：function
向表格指定位置插入行，天软表格行下标从0开始
<!-- tags: 添加 追加 -->
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------------------------------ |
| `t` | array | Array,数组，支持一维，二维数组，只支持下标为自增长的序列数组 |
| `index` | integer | Integer,插入行的起始下标，下标位置从０开始 |
| `rdata` | any | Any,插入的数据，支持一个值、一维表及二维表 |
返回：array
### 示例
范例1：
```tsl
// 向一维数组指定位置插入一个字符串 'aaa'
t := 43456->43460;
index := 2;
r_data := 'aaa';
return inserttablebyrno(t, index, r_data);
// 输出：array(43456,43457,"aaa",43458,43459,43460)
```
范例02：插入多行数据
```tsl
// 向一维数组第3行插入多行的数据
t := 44000->44004;
index := 3;
r_data := array('a', 'b', 'c');
return inserttablebyrno(t, index, r_data);
// 输出：
// array(44000, 44001, 44002, "a", "b", "c", 44003, 44004)
```
范例3：
```tsl
// 向二维数组第3行插入多行的数据
t := array(('a': 10, 'b': 'i', 'c': dateToStr(20200319T)),
('a': 50, 'b': 'i', 'c': dateToStr(20200318T)),
('a': 60, 'b': 'i', 'c': dateToStr(20200317T)),
('a': 40, 'b': 'o', 'c': dateToStr(20200316T)),
('a': 20, 'b': 'o', 'c': dateToStr(20200313T)));
index := 3;
r_data := array(('c': 0, 'b': 44000, 'a': '2020-03-20'));
return inserttablebyrno(t, index, r_data);
// 输出：
// array(
// ("a":10,"b":"i","c":"2020-03-19"),
// ("a":50,"b":"i","c":"2020-03-18"),
// ("a":60,"b":"i","c":"2020-03-17"),
// ("c":0,"b":44000,"a":"2020-03-20"),
// ("a":40,"b":"o","c":"2020-03-16"),
// ("a":20,"b":"o","c":"2020-03-13"))
```
范例4：
```tsl
// 向二维数组第1行插入多行的数据
t := array(('a': 10, 'b': 'i', 'c': dateToStr(20200319T)),
('a': 50, 'b': 'i', 'c': dateToStr(20200318T)),
('a': 60, 'b': 'i', 'c': dateToStr(20200317T)),
('a': 40, 'b': 'o', 'c': dateToStr(20200316T)),
('a': 20, 'b': 'o', 'c': dateToStr(20200313T)));
index := 1;
r_data := array(('c': '2020', 'b': 'AAA', 'a': 44456),
('c': '2020', 'b': 'BBB', 'a': 44566));
return inserttablebyrno(t, index, r_data);
// 输出：
// array(
// ("a":10,"b":"i","c":"2020-03-19"),
// ("c":"2020","b":"AAA","a":44456),
// ("c":"2020","b":"BBB","a":44566),
// ("a":50,"b":"i","c":"2020-03-18"),
// ("a":60,"b":"i","c":"2020-03-17"),
// ("a":40,"b":"o","c":"2020-03-16"),
// ("a":20,"b":"o","c":"2020-03-13"))
```
## `intersectionPart(v, w)`
声明：function
求交集
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `v` | array | 数组 |
| `w` | array | 数组 |
返回：array
### 示例
```tsl
t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return intersectionPart(t1, t2);
```
## `inverseTable(t)`
声明：function
将数组t去掉第一列转置，转置后原数组t的第一列作为行标
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `t` | array | 数据表类型 |
返回：array
### 示例
```tsl
s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
array('A': 2, 'B': 3, 'C': 4, 'D': 5, 'e': 6),
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7), );
return inverseTable(s);
// 输出：
```
## `istable(t)`
声明：function
判断是否为数组。如果t为数据表，返回True；否则，返回False
<!-- tags: 判断 检查 -->
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：bool
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return istable(t1);
// 输出：1
```
## `kurtByColumn(t, f_name)`
声明：function
指定列的峰度
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return kurtByColumn(t2, 'c');
// 输出：0.34
```
## `maxValueByColumn(t, f_name)`
声明：function
求指定列中的最大值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return maxValueByColumn(t2, 'c');
// 输出：53
```
## `medianByColumn(t, f_name)`
声明：function
指定列的中位数
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return medianByColumn(t2, 'c');
// 输出：38
```
## `mergeArray(v1, v2, ...)`
声明：function
多个数组进行合并
| 参数 | 类型 | 说明 |
| ----- | ----- | ---- |
| `v1` | array | |
| `v2` | array | |
| `...` | | |
返回：array
### 示例
```tsl
t1 := array(('b': 12, 'a': 1, 'c': 13, 'd': 'd'));
t2 := array(('a': 2, 'b': 22, 'c': 23, 'e': 'ee'));
t3 := array(('a': 2, 'b': 22, 'd': 23, 'e': 'ee'));
return mergeArray(t1, t2, t3); // 将数组t1,t2,t3合并
```
## `minValueByColumn(t, f_name)`
声明：function
求指定中的最小值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return minValueByColumn(t2, 'c');
// 输出：13
```
## `nonIntersectionPart(t1, t2, key_field)`
声明：function
求差集(返回在t1中存在，而在t2中不存在的记录)
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------ |
| `t1` | array | 数据表 |
| `t2` | array | 数据表 |
| `key_field` | string | 指定某一字段 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
t2 := array(('a': 1, 'b': 1), ('a': 7, 'b': 8), ('a': 5, 'b': 5));
return nonIntersectionPart(t1, t2, 'b');
// 输出：
// array(3,4)
```
## `noRecordTable()`
声明：function
返回一个空数组
<!-- tags: 返回 获取 -->
返回：array,tablearray
### 示例
```tsl
return noRecordTable();
// 输出：Array()
```
## `normalTabletoStrSubscript(t, key_field)`
声明：function
索引下标数组-->字符串下标数组。将keyfield列的值变为行标
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------ |
| `t` | array | 数据表类型 |
| `key_field` | string | 字符串，列名 |
返回：any
### 示例
```tsl
s := nDay(10, 'time', dateToStr(sp_time()), 'close', close());
return normalTabletoStrSubscript(s, 'time');
// 把 time列的数据变为行标
```
## `outPutTableToCanBeUnderstood(t)`
声明：function
判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组
<!-- tags: 判断 检查 -->
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------- |
| `t` | array | 数组，数据表。 |
返回：string|array
### 示例
```tsl
return outPutTableToCanBeUnderstood(array(1, 2, 3));
// 输出：
```
## `passwordGen(len, n, head, start)`
声明：function
密码生成器
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------ |
| `len` | integer | 整数，密码长度 |
| `n` | integer | 整数，生成的密码组合数 |
| `head` | string | 字符串，用户名的前缀 |
| `start` | integer | 整数，用户名的后缀序列数字的起始数字 |
返回：array
### 示例
范例01：生成五组密码
```tsl
return passwordGen(8, 5, 'ts', 3);
```
此示例需在提供 `passwordGen` 的 Windows/.NET 运行环境中执行。本地 `.tsl` 脚本不使用 `rdo2` 包装调用。
## `percentValueByField(t, key_field, quart)`
声明：function
数据集在指定百分位数上对应的数值
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `key_field` | string | 指定列名，字符串 |
| `quart` | real | 指定分位数，实数 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return percentValueByField(t2, 'c', 0.1);
// 输出：19
```
## `pivot(t, index, columns, vals)`
声明：function
透视，数据透视表
| 参数 | 类型 | 说明 |
| --------- | --------------- | -------------------------------------------------------------------------------------------------------- |
| `t` | array | 二维数组，待透视表，t[:,array(index,columns)] 不能包含重复的行，即index，columns 必须可以作为t的唯一主键 |
| `index` | string \| array | 字符串或一维字符串数组，行分类字段，t的列名，多个字段可以用数组，为nil表示取t的行下标 |
| `columns` | string \| array | 字符串或一维字符串数组，列分类字段，t的列名；结果列名形如 `值字段@列分类值` |
| `vals` | string \| array | 字符串或一维字符串数组，值字段，t的列名，多个字段可以用数组 |
返回：array
### 示例
```tsl
// 行标为日期、列标为名称，值为收盘价和涨幅的数据透视表
t := array(
("日期":"2021-05-17", "名称":"平安银行", "收盘价":22.5, "涨幅":1.2),
("日期":"2021-05-17", "名称":"万科A", "收盘价":30.1, "涨幅":-0.8),
("日期":"2021-05-18", "名称":"平安银行", "收盘价":22.9, "涨幅":1.8),
("日期":"2021-05-18", "名称":"万科A", "收盘价":29.7, "涨幅":-1.3));
return pivot(t, "日期", "名称", array("收盘价", "涨幅"));
// 输出：
// array("2021-05-17":
// ("收盘价@万科A":30.1,"收盘价@平安银行":22.5,"涨幅@万科A":-0.8,"涨幅@平安银行":1.2),"2021-05-18":
// ("收盘价@万科A":29.7,"收盘价@平安银行":22.9,"涨幅@万科A":-1.3,"涨幅@平安银行":1.8))
```
## `Pivot_table(t, index, columns, vals, aggfunc, aggfuncnames)`
声明：function
分组、透视、汇总 1、vals 未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 2、aggfunc 不同含义及设定方法： a、所有字段，统一函数 aggfunc := "avg" 注：代表对vals中所有字段进行计算 b、所有字段，多个函数 aggfunc := array("avg","max"); c、指定字段，指定函数 aggfunc := array("fielda":"avg","filedb":("avg","max")); 注：指定字段时，必须是vals的子集，否则报错。 3、支持匿名函数、与函数指针，其中: a、匿名函数默认命名为"匿名" b、函数指针通过functioninfo得到函数名称 4、aggfunc中支持 a、所有 TS_SQL 聚合函数：e.g:"avg"(avgof),"sum"(sumof) b、内置函数： "\_details": 分组详情 "\_first": 第一个 "\_last": 最后一个 c、自定义函数中使用关键字thisgroup 得到当前分组数据。 5、index/columns中字段值含有nill等不可设为索引。 6、aggfuncnames：给aggfunc定义名称
<!-- tags: TS_SQL -->
| 参数 | 类型 | 说明 |
| -------------- | ----------------------- | ------------------------ |
| `t` | array | 数据表 |
| `index` | string\|array | 行分类字段 |
| `columns` | string\|array | 列分类字段 |
| `vals` | string\|array | 值字段 |
| `aggfunc` | string\|array\|function | 汇总函数 |
| `aggfuncnames` | array | 自定义汇总函数名称对照表 |
返回：array
### 示例
```tsl
data := array(
("group": "A", "date": "2025-01-01", "value": 1),
("group": "A", "date": "2025-01-02", "value": 2),
("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(Pivot_table(
data,
"group",
"date",
"value",
"sum",
nil
)));
```
## `QKsplit_Resampling(begt, endt, cy, if_name)`
声明：function
区间自然日按指定周期重采样分割
| 参数 | 类型 | 说明 |
| --------- | -------- | ---------------------------------------------------------------------------- |
| `begt` | datetime | 日期时间，开始日 |
| `endt` | datetime | 日期时间，截止日 |
| `cy` | string | 字符串，采样周期，默认为cy_Day()，可以取日线、周线、月线、季线、半年线、年线 |
| `if_name` | string | object |
返回：array
### 示例
```tsl
echo trim(toStn(QKsplit_Resampling(20100101T, 20110101T, cy_year(), "")));
```
## `QKsplit_ToDate(endt, _type)`
声明：function
当前周期分割区间
| 参数 | 类型 | 说明 |
| ------- | -------- | ----------------------------------------------------------------------- |
| `endt` | datetime | 日期时间，截止日 |
| `_type` | any | 整型，为以下数值的组合(以下数值的\_XOR或者相加)，默认值为31(1+2+4+8+16) |
返回：array
### 示例
```tsl
echo trim(toStn(QKsplit_ToDate(20220704T, 31)));
```
## `QKsplit_Trailing(begt, endt, inc_weeks, inc_months, inc_years, other_type)`
声明：function
时间区间尾随分割
| 参数 | 类型 | 说明 |
| ------------ | -------- | ------------------------------------------------------ |
| `begt` | datetime | 日期时间，开始日 |
| `endt` | datetime | 日期时间，截止日 |
| `inc_weeks` | any | 数字/数组，周推移，取值如下 |
| `inc_months` | any | 数字/数组，月推移，同inc_weeks |
| `inc_years` | any | 数字/数组，年推移，同inc_weeks |
| `other_type` | any | 整型，为以下数值的组合(以下数值的\_XOR或者相加)，默认2 |
返回：array
### 示例
```tsl
echo trim(toStn(QKsplit_Trailing(20100101T, 20110101T, nil, nil, nil, 2)));
```
## `quickIntersectionPart(v, w)`
声明：function
快速求交集
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `v` | array | 数组 |
| `w` | array | 数组 |
返回：array
### 示例
```tsl
t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return intersectionPart(t1, t2);
```
## `quickRecordExist(v, x)`
声明：function
记录是否存在(原数组若为纯字符串数组则必须为有序列)，返回记录所在行的序号，序号是从0开始原数组必须为有序表
| 参数 | 类型 | 说明 |
| ---- | ------ | ----------- |
| `v` | array | 一维数组 |
| `x` | string | 字符串/数字 |
返回：integer
### 示例
```tsl
t := array('a', 'c', 'd');
return quickRecordExist(t, 'd');
// 输出：2
```
## `randomchoice(avalues, size, replace)`
声明：function
随机抽样
| 参数 | 类型 | 说明 |
| --------- | --------------- | ---------------------------------------- |
| `avalues` | array of string | Array of string,一维字符串数组，或正整数 |
| `size` | integer | Integer, |
| `replace` | bool | Bool,是否可放回,默认为真可放回 |
返回：any
### 示例
```tsl
// 从字符串数组中有放回随机抽取 3 个
return randomchoice(array("A", "B", "C", "D", "E"), 3, true);
// 输出：长度为 3 的随机子集，如 array("B","A","C")；因随机抽样每次运行结果不同。
// 若 avalues 传正整数 n，则从 0..n-1 中抽样，返回浮点下标数组。
```
## `rankIt(t, f_n, sort_order)`
声明：function
按指定字段的值排名；SortOrder：0 降序排名；SortOrder：1升序排名
<!-- tags: 排序 sort -->
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `t` | array | 数据表 |
| `f_n` | string | 字段名 |
| `sort_order` | integer | 排名方向，0 降序排名, 1升序排名 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
rankIt(t2, 'c', 1);
return t2;
// 输出：
// array(
// ("a":2,"c":13,"c排名":1),
// ("a":3,"c":33,"c排名":2))
```
## `rankIt2(t, f_n, of_n, sort_order)`
声明：function
按指定字段的值排名，SortOrder:0 降序排名；SortOrder:1 升序排名，排名列的字段为：OfN
<!-- tags: 排序 sort -->
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `t` | array | 数据表 |
| `f_n` | string | 指定字段，字符串 |
| `of_n` | string | 排名列字段名，字符串 |
| `sort_order` | integer | 排名方向:0 降序排名，1 升序排名 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
rankIt2(t2, 'c', '名次', 1);
return t2;
// 输出：
// array(
// ("a":2,"c":13,"名次":1),
// ("a":3,"c":33,"名次":2))
```
## `rankValue(t, fields)`
声明：function
按照指定字段求Rank,返回的数据，保存在传递过来的数据t中。返回按Fields列排序的结果
<!-- tags: 排序 sort -->
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `fields` | string | 字符串，排序的列 |
返回：any
### 示例
```tsl
// 对涨幅列进行排名，结果新增"涨幅(%)排名"列，并按排名升序重排
data := array(
("代码":"SH600000", "名称":"浦发银行", "收盘":10.77, "涨幅(%)":0.37),
("代码":"SH600016", "名称":"民生银行", "收盘":5.94, "涨幅(%)":-0.17),
("代码":"SH600028", "名称":"中国石化", "收盘":5.74, "涨幅(%)":0.17),
("代码":"SH600030", "名称":"中信证券", "收盘":18.58, "涨幅(%)":1.75),
("代码":"SH600036", "名称":"招商银行", "收盘":29.3, "涨幅(%)":0.31),
("代码":"SH600050", "名称":"中国联通", "收盘":5.36, "涨幅(%)":0.94));
rankValue(data, '涨幅(%)');
return data;
// 输出：
// array(
// ("代码":"SH600030","名称":"中信证券","收盘":18.58,"涨幅(%)":1.75,"涨幅(%)排名":1),
// ("代码":"SH600050","名称":"中国联通","收盘":5.36,"涨幅(%)":0.94,"涨幅(%)排名":2),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.37,"涨幅(%)排名":3),
// ("代码":"SH600036","名称":"招商银行","收盘":29.3,"涨幅(%)":0.31,"涨幅(%)排名":4),
// ("代码":"SH600028","名称":"中国石化","收盘":5.74,"涨幅(%)":0.17,"涨幅(%)排名":5),
// ("代码":"SH600016","名称":"民生银行","收盘":5.94,"涨幅(%)":-0.17,"涨幅(%)排名":6))
```
## `recordExist(t, v)`
声明：function
数值是否在数组中存在（一维数组），如果存在，则返回索引号；(索引号从0开始)不存在，返回－1
| 参数 | 类型 | 说明 |
| ---- | ------ | ------------------------------- |
| `t` | array | 指定一维数组 |
| `v` | string | 要查询的数值，与t单元值类型一致 |
返回：integer
### 示例
```tsl
t := array(1, 2, 12, 3, 14);
return recordExist(t, 12);
// 输出：2
```
## `recordExist2(t, f_name, v)`
声明：function
记录数据表（二维数组）中是否存在列名为fName，值为V的记录；如果存在，则返回行标索引号(索引号从0开始)，不存在，返回－1
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------- |
| `t` | array | 指定数组，二维数组 |
| `f_name` | string | 指定列名，字符串 |
| `v` | string | 指定值，与t单元值类型一致 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return recordExist2(t1, 'b', 3);
// 输出：2
```
## `recordExist3(v, x)`
声明：function
记录指定值是否存在一维数组中，如果存在，返回1，不存在，返回0
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------- |
| `v` | string | 指定数组，一维数组 |
| `x` | integer | 指定值，与v单元值类型一致 |
返回：bool
### 示例
```tsl
t := array(1, 2, 12, 3, 14);
return recordExist3(t, 3);
// 输出：1
```
## `renameField(t, old_field, new_field)`
声明：function
修改指定字段的名称
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------- |
| `t` | array | 指定数组，数据表 |
| `old_field` | string | 原来指定列名，字符串 |
| `new_field` | string | 新列名，字符串 |
返回：bool
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return renameField(t1, 'a', 'aaa'); // 将 t1 中的字段 'a' 改为 'aaa'
// 输出：1
```
## `reverse(arr)`
声明：function
数组倒置反向
| 参数 | 类型 | 说明 |
| ----- | ----- | ---- |
| `arr` | array | 数组 |
返回：array
### 示例
```tsl
arr := array(
("date":"2021-05-26", "close":1),
("date":"2021-05-27", "close":2),
("date":"2021-05-28", "close":3),
("date":"2021-05-31", "close":4),
("date":"2021-06-01", "close":5));
return reverse(arr);
// 输出：
// array(
// ("date":"2021-06-01","close":5),
// ("date":"2021-05-31","close":4),
// ("date":"2021-05-28","close":3),
// ("date":"2021-05-27","close":2),
// ("date":"2021-05-26","close":1))
```
## `rotateTable(data)`
声明：function
旋转表
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------------- |
| `data` | array | 数据表，二维数组 |
返回：array
### 示例
```tsl
t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return rotateTable(t);
```
## `rpsIt(t, f_n, sort_order)`
声明：function
按指定字段的值排名，获得其排名的百分位，排序百分位放在列 FN+"\_RPS"中
<!-- tags: 排序 sort FN -->
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `t` | array | 数组，数据表 |
| `f_n` | string | 字符串/数字，字段名 |
| `sort_order` | integer | 排名方向，0 降序排名, 1升序排名 |
返回：array
### 示例
```tsl
r := array(
("StockID":"SZ000001", "StockName":"平安银行", "StockZF":0.28),
("StockID":"SZ000002", "StockName":"万 科Ａ", "StockZF":-0.12),
("StockID":"SH600997", "StockName":"开滦股份", "StockZF":0.66),
("StockID":"SZ000009", "StockName":"中国宝安", "StockZF":2.47),
("StockID":"SZ000012", "StockName":"南 玻Ａ", "StockZF":1.27),
("StockID":"SZ000024", "StockName":"招商地产", "StockZF":0.05));
return rpsIt(r, 'StockZF', 1);
// 输出：
// array(
// ("StockID":"SZ000009","StockName":"中国宝安","StockZF":2.47,"StockZF_RPS":100.0),
// ("StockID":"SZ000012","StockName":"南 玻Ａ","StockZF":1.27,"StockZF_RPS":80.0),
// ("StockID":"SH600997","StockName":"开滦股份","StockZF":0.66,"StockZF_RPS":60.0),
// ("StockID":"SZ000001","StockName":"平安银行","StockZF":0.28,"StockZF_RPS":40.0),
// ("StockID":"SZ000024","StockName":"招商地产","StockZF":0.05,"StockZF_RPS":20.0),
// ("StockID":"SZ000002","StockName":"万 科Ａ","StockZF":-0.12,"StockZF_RPS":0.0))
```
## `rpsValue(t, column_name)`
声明：function
按照指定字段求RPS
<!-- tags: RPS -->
| 参数 | 类型 | 说明 |
| ------------- | ------ | ----------------------- |
| `t` | array | 数据表类型，数据表 |
| `column_name` | string | 字符串，要计算RPS的字段 |
返回：any
### 示例
```tsl
s := array(
("代码":"SZ000001", "名称":"平安银行", "收盘":11.2, "涨幅(%)":0.900900900900892),
("代码":"SZ000002", "名称":"万 科Ａ", "收盘":27.68, "涨幅(%)":-0.25225225225225),
("代码":"SH600000", "名称":"浦发银行", "收盘":10.77, "涨幅(%)":0.372786579683115),
("代码":"SH600100", "名称":"同方股份", "收盘":8.73, "涨幅(%)":1.74825174825175));
rpsValue(s, '涨幅(%)');
return s;
// 输出：
// array(
// ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175,"RPS_涨幅(%)":100.0),
// ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892,"RPS_涨幅(%)":66.6666666666667),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115,"RPS_涨幅(%)":33.3333333333333),
// ("代码":"SZ000002","名称":"万 科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225,"RPS_涨幅(%)":0.0))
```
## `searchsorted(v, x)`
声明：function
有序列表插入指定值的位置，原数组必须为有序表且元素应可比较
<!-- tags: 排序 sort 查找 搜索 lookup 获取 查询 -->
| 参数 | 类型 | 说明 |
| ---- | -------------- | ----------------- |
| `v` | array | 一维数组 有序数组 |
| `x` | string \| real | 插入的值 |
返回：integer
### 示例
范例1：数字插入
```tsl
v := array(1, 2, 3, 4, 5, 6);
return searchsorted(v, 3.5); // 输出：3
```
范例2：字符串插入
```tsl
v := array("SH600001", "SH600004", "SH600050", "SH600305");
return searchsorted(v, "SH600049"); // 输出：2
```
## `seekPosInArray(r, arr)`
声明：function
数字定位，采用二分法寻找数字R在一位正序数字数组arr中的下标
| 参数 | 类型 | 说明 |
| ----- | ----- | ------------ |
| `r` | real | 实数 |
| `arr` | array | 一维数字数组 |
返回：integer
### 示例
```tsl
return seekPosInArray(4, array(1, 2, 3, 4, 5));
// 输出：3
```
## `seperateTable(t, sep_field, sep_count)`
声明：function
把表格t分割为SepCount个表格
| 参数 | 类型 | 说明 |
| ----------- | ------- | -------------------- |
| `t` | array | 数据表类型，原始数组 |
| `sep_field` | string | 字符串，排序字段 |
| `sep_count` | integer | 整数，分割数 |
返回：array
### 示例
```tsl
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return seperateTable(t, 'a', 2);
// 输出：
// array(
// (
// ("a":4,"b":5,"c":6,"d":7,"e":8,"f":10),
// ("a":3,"b":4,"c":5,"d":6,"e":7,"f":9)),
// (
// ("a":2,"b":3,"c":4,"d":5,"e":6,"f":8),
// ("a":1,"b":2,"c":3,"d":4,"e":5,"f":7)))
```
## `setRowDefaultValue(t, n, value)`
声明：function
将数组t的第N行由所有值变更为Value
<!-- tags: 设置 修改 -->
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `n` | integer | 整数，行号 |
| `value` | string | 字符串，要设置的值 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6));
setRowDefaultValue(s, 2, 'wo');
return s;
// 输出：
```
## `show2DTable(t, key_field, obsolete_fields, ntype)`
声明：function
特殊函数，平台功能性函数，一般用户不使用。二位表格显示格式转换，其中t为原数据,KeyField为需要转置的字段，ObsoleteFields为需要隐藏的字段，NType决定显示格式
| 参数 | 类型 | 说明 |
| ----------------- | ------- | ---------------------------- |
| `t` | array | 数据表类型，原数据 |
| `key_field` | string | 字符串，要显示倒置的关键字段 |
| `obsolete_fields` | string | 字符串，不显示的字段(;分割) |
| `ntype` | integer | 用户自定义，二维表格显示格式 |
返回：array
### 示例
```tsl
// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "主营业务收入": 151953.06, "主营业务利润": 30559.66, "营业费用": 10112.75, "管理费用": 10666.36, "财务费用": -894.46, "营业利润": 10693.23, "投资收益": -151.01, "利润总额": 9904.7, "所得税": 2413.81, "净利润": 7873.08, "货币资金": -11664.28, "短期投资": -5370.7, "主营业务收入": 167855.56, "主营业务利润": 31127.95, "营业费用": 4452.79, "管理费用": 10541.15, "财务费用": -1013.26, "营业利润": 17162.48, "投资收益": 150.81, "利润总额": 17246.26, "所得税": 2629.5, "净利润": 14574.03, "货币资金": 532.5, "短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "主营业务收入": 19715.3, "主营业务利润": 10383.2, "营业费用": 238.4, "管理费用": 1422.7, "财务费用": 1304.4, "营业利润": 7417.7, "投资收益": 81.1, "利润总额": 6404.6, "所得税": 2433.4, "净利润": 3971.2, "货币资金": 2964.5, "短期投资": 0.00, "主营业务收入": 17727.7, "主营业务利润": 9989.1, "营业费用": 165.5, "管理费用": 1151.3, "财务费用": -18.2, "营业利润": 8690.5, "投资收益": 186.2, "利润总额": 9208.6, "所得税": 2977.1, "净利润": 6231.5, "货币资金": -8101.2, "短期投资": 0.00));
return show2DTable(t, '名称', '代码', 2);
// 输出：
```
## `show3DTable(t, key_field, obsolete_fields, ntype)`
声明：function
特殊函数，平台功能性函数，一般用户不使用。用于三维表格显示格式转换，其中t为原数据,KeyField为需要转置的字段，ObsoleteFields为需要隐藏的字段，NType决定显示格式
| 参数 | 类型 | 说明 |
| ----------------- | ------- | ---------------------------- |
| `t` | array | 数据表类型，原数据 |
| `key_field` | string | 字符串，要显示倒置的关键字段 |
| `obsolete_fields` | string | 字符串，不显示的字段(;分割) |
| `ntype` | integer | 用户自定义，三维表格显示格式 |
返回：array
### 示例
```tsl
// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "2004.10-12@主营业务收入": 151953.06, "2004.10-12@主营业务利润": 30559.66, "2004.10-12@营业费用": 10112.75, "2004.10-12@管理费用": 10666.36, "2004.10-12@财务费用": -894.46, "2004.10-12@营业利润": 10693.23, "2004.10-12@投资收益": -151.01, "2004.10-12@利润总额": 9904.7, "2004.10-12@所得税": 2413.81, "2004.10-12@净利润": 7873.08, "2004.10-12@货币资金": -11664.28, "2004.10-12@短期投资": -5370.7, "2004.7-9@主营业务收入": 167855.56, "2004.7-9@主营业务利润": 31127.95, "2004.7-9@营业费用": 4452.79, "2004.7-9@管理费用": 10541.15, "2004.7-9@财务费用": -1013.26, "2004.7-9@营业利润": 17162.48, "2004.7-9@投资收益": 150.81, "2004.7-9@利润总额": 17246.26, "2004.7-9@所得税": 2629.5, "2004.7-9@净利润": 14574.03, "2004.7-9@货币资金": 532.5, "2004.7-9@短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "2004.10-12@主营业务收入": 19715.3, "2004.10-12@主营业务利润": 10383.2, "2004.10-12@营业费用": 238.4, "2004.10-12@管理费用": 1422.7, "2004.10-12@财务费用": 1304.4, "2004.10-12@营业利润": 7417.7, "2004.10-12@投资收益": 81.1, "2004.10-12@利润总额": 6404.6, "2004.10-12@所得税": 2433.4, "2004.10-12@净利润": 3971.2, "2004.10-12@货币资金": 2964.5, "2004.10-12@短期投资": 0.00, "2004.7-9@主营业务收入": 17727.7, "2004.7-9@主营业务利润": 9989.1, "2004.7-9@营业费用": 165.5, "2004.7-9@管理费用": 1151.3, "2004.7-9@财务费用": -18.2, "2004.7-9@营业利润": 8690.5, "2004.7-9@投资收益": 186.2, "2004.7-9@利润总额": 9208.6, "2004.7-9@所得税": 2977.1, "2004.7-9@净利润": 6231.5, "2004.7-9@货币资金": -8101.2, "2004.7-9@短期投资": 0.00), ("代码": "SH600004", "名称": "白云机场", "2004.7-9@主营业务收入": 37934.65, "2004.7-9@主营业务利润": 15725.54, "2004.7-9@营业费用": 2623.82, "2004.7-9@管理费用": 4662.1, "2004.7-9@财务费用": 1789.5, "2004.7-9@营业利润": 6650.11, "2004.7-9@投资收益": -15.38, "2004.7-9@利润总额": 6685.16, "2004.7-9@所得税": 2350.15, "2004.7-9@净利润": 4000.51, "2004.7-9@货币资金": -5054.06, "2004.7-9@短期投资": 101.00));
return show3DTable(t, '名称', '代码', 3);
// 输出：
```
## `showTableByField(t, field_arr)`
声明：function
显示数据表t的部分字段数据，字段在FieldArr的数组里
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------------- |
| `t` | array | 数据表类型，数据 |
| `field_arr` | array | 一维数组，要显示的字段 |
返回：array
### 示例
```tsl
arr := array((1, 2, 3, 4, 5), (2, 3, 4, 5, 6), (3, 4, 5, 6, 7), (4, 5, 6, 7, 8));
return showTableByField(arr, array(1, 2, 3));
// 输出：
```
## `showTableByInverse(t, key_field, field_arr, show_number)`
声明：function
数据表t转置，其中KeyField为列名，该列的数据转置后作为列标名，FieldARR为需要显示的字段，ShowNumber表示显示原数据keyfield行(转置后列)的数量
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------------------------------------------ |
| `t` | array | 数据表类型，数据 |
| `key_field` | string | 字符串，转置后用作列标的值的列名 |
| `field_arr` | array | 数组，要显示的字段列表，给非数组则显示所有字段。 |
| `show_number` | integer | 整数，显示个数 |
返回：array
### 示例
```tsl
// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "主营业务收入": 151953.06, "主营业务利润": 30559.66, "营业费用": 10112.75, "管理费用": 10666.36, "财务费用": -894.46, "营业利润": 10693.23, "投资收益": -151.01, "利润总额": 9904.7, "所得税": 2413.81, "净利润": 7873.08, "货币资金": -11664.28, "短期投资": -5370.7, "主营业务收入": 167855.56, "主营业务利润": 31127.95, "营业费用": 4452.79, "管理费用": 10541.15, "财务费用": -1013.26, "营业利润": 17162.48, "投资收益": 150.81, "利润总额": 17246.26, "所得税": 2629.5, "净利润": 14574.03, "货币资金": 532.5, "短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "主营业务收入": 19715.3, "主营业务利润": 10383.2, "营业费用": 238.4, "管理费用": 1422.7, "财务费用": 1304.4, "营业利润": 7417.7, "投资收益": 81.1, "利润总额": 6404.6, "所得税": 2433.4, "净利润": 3971.2, "货币资金": 2964.5, "短期投资": 0.00, "主营业务收入": 17727.7, "主营业务利润": 9989.1, "营业费用": 165.5, "管理费用": 1151.3, "财务费用": -18.2, "营业利润": 8690.5, "投资收益": 186.2, "利润总额": 9208.6, "所得税": 2977.1, "净利润": 6231.5, "货币资金": -8101.2, "短期投资": 0.00));
return showTableByInverse(t, '代码', '', 2);
// 输出：
```
## `ShowTableByUnit(t, field_arr)`
声明：function
显示t部分字段(带显示单位变换)。其中FieldArr为二维数组，FieldArr的第0列为显示的字段名称，第1列为显示的字段对应的数据列名称，第2列为显示的字段的数据类型，第3列为显示的字段的单位(只对Real类型有意义)
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------------------- |
| `t` | array | 数据表类型，要显示的数据 |
| `field_arr` | array | 二位字符串数组，要显示的字段 |
返回：Array，数组。
### 示例
```tsl
data := array("a": (1, 2), "b": (3, 4));
fields := array(("field_a", "a", "", ""));
echo trim(toStn(ShowTableByUnit(data, fields)));
```
## `simpledescribe(data)`
声明：function
简单描述统计
| 参数 | 类型 | 说明 |
| ------ | --------------- | ----------------------------------------------------- |
| `data` | array of number | 一维数字数组，或 二维矩阵，二维矩阵时，对每列进行操作 |
返回：array
### 示例
```tsl
data := array(
("H": 10, "W": 2, "L": 4),
("H": 20, "W": 4, "L": 8),
("H": 30, "W": 6, "L": 12));
return simpledescribe(data);
// 输出：
// array("个数":
// ("H":3,"W":3,"L":3),"最小值":
// ("H":10.0,"W":2.0,"L":4.0),"25%":
// ("H":15.0,"W":3.0,"L":6.0),"50%":
// ("H":20.0,"W":4.0,"L":8.0),"75%":
// ("H":25.0,"W":5.0,"L":10.0),"最大值":
// ("H":30.0,"W":6.0,"L":12.0),"平均值":
// ("H":20.0,"W":4.0,"L":8.0),"标准差":
// ("H":10.0,"W":2.0,"L":4.0))
```
## `skewByColumn(t, f_name)`
声明：function
指定列的偏度
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return skewByColumn(t2, 'c');
// 输出：-0.75
```
## `sortTableByFieldExt(t, sort_field)`
声明：function
将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并
<!-- tags: 排序 sort -->
| 参数 | 类型 | 说明 |
| ------------ | ------ | ---------------- |
| `t` | array | 数据表类型，数组 |
| `sort_field` | string | 字符串,排序字段 |
返回：any
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return sortTableByFieldExt(s, 'b');
// 输出：
```
## `sparse1(s, a, m, n)`
声明：function
挤出任何非零元素，将满矩阵转化为稀疏格式，与Sparsefull函数对应
| 参数 | 类型 | 说明 |
| ---- | ------------- | --------------------------------- |
| `s` | array of real | 待转化的m\*n满矩阵 |
| `a` | array of real | 变参返回矩阵S的稀疏格式，二维数组 |
| `m` | integer | 变参返回矩阵S的行数，整数 |
| `n` | integer | 变参返回矩阵S的列数，整数 |
返回：array
### 示例
```tsl
// 将矩阵S由满矩阵格式转化为稀疏格式
s := array((0, 0, 4, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 0, 0, 0),
(3, 0, 0, 0, 0),
(0, 0, 0, 0, 5));
return sparse1(s);
// 输出：
// array(0:
// (2:4),1:
// (1:1),3:
// (3),4:
// (4:5))
```
## `sparse2(i, j, v, m, n)`
声明：function
根据i、j和v三元组生成m\*n稀疏格式矩阵S
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------ |
| `i` | array of real | 存放矩阵行标的一元数组 |
| `j` | array of real | 存放矩阵列标的一元数组 |
| `v` | array of real | 存放矩阵元素值的一元数组 |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
返回：array
### 示例
```tsl
// 根据i,j,v三元组生成稀疏格式矩阵
i := array(0, 1, 2, 3);
j := array(3, 1, 4, 2);
v := array(5, 3, 2, 4);
return sparse2(i, j, v, 5, 5);
// 输出：
// array(
// (3:5),
// (1:3),
// (4:2),
// (2:4))
```
## `sparsefull(s, m, n)`
声明：function
将稀疏矩阵格式转化为满矩阵，与Sparse1函数相对应
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------ |
| `s` | array of real | 稀疏格式矩阵 |
| `m` | integer | 转化为满矩阵的行数，整数 |
| `n` | integer | 转化为满矩阵的列数，整数 |
返回：array
### 示例
```tsl
// 将S由稀疏格式矩阵转化为5*5满矩阵格式
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return sparsefull(s, 5, 5);
// 输出：
// array(
// (1,0,0,0,0),
// (0,0,0,0,0),
// (0,0,3,0,0),
// (0,0,0,4,0),
// (0,0,0,0,0))
```
## `sparseMatFill(a, fillv)`
声明：function
稀疏数据表填充，直接在A矩阵上更改
| 参数 | 类型 | 说明 |
| ------- | ---------------- | -------------------- |
| `a` | array,tablearray | 数据表类型，稀疏矩阵 |
| `fillv` | real | 实数，给定的填充值 |
返回：array,tablearray
### 示例
```tsl
a := array((3: 4), ('A': 2));
sparseMatFill(a, -1);
return a; // 输出：array((3:4,"A":-1),(3:-1,"A":2))
```
## `spdiags1(a)`
声明：function
提取矩阵非零对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
返回：array
### 示例
```tsl
// 提取矩阵A中非零对角线
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags1(a);
```
## `spdiags2(a, d)`
声明：function
提取矩阵指定对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------------------ |
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
| `d` | array | Array,一维数组，对角线序列；也可以为数字； |
返回：array
### 示例
```tsl
// 提取矩阵A中第-2,0,2条对角线，按列排列
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
d := array(-2, 0, 2);
return spdiags2(a, d);
```
## `spdiags3(b, d, a)`
声明：function
根据指定列替换稀疏矩阵对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `b` | array | Array,二维数组，对角矩阵 |
| `d` | array | Array,一维数组，对角线序列 |
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
返回：array
### 示例
```tsl
// 将矩阵A中d指定的对角线替换为B中的列
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags3(b, d, a);
```
## `spdiags4(b, d, m, n)`
声明：function
根据指定列创建稀疏矩阵
| 参数 | 类型 | 说明 |
| ---- | ------- | -------------------------------- |
| `b` | array | Array,二维数组，对角矩阵 |
| `d` | array | Array,一维数组，对角线序列 |
| `m` | integer | Integer,正整数，（稀疏）矩阵的行 |
| `n` | integer | Integer,正整数，（稀疏）矩阵的列 |
返回：array
### 示例
```tsl
// 根据对角矩阵B创建稀疏带状矩阵
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
m := 5;
n := 5;
return spdiags4(b, d, m, n);
```
## `spnnz(s)`
声明：function
稀疏矩阵S中的非零元素数目
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：integer
### 示例
```tsl
// 稀疏正态随机矩阵A中非零元素数目
a := sprandn2(5, 5, 0.2);
return spnnz(a); // 返回4（随机）
```
## `spnonzeros(s)`
声明：function
提取稀疏矩阵S中的非零元素
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 提取稀疏正态随机矩阵A中非零元素
a := sprandn2(5, 5, 0.2);
return spnonzeros(a);
// 输出：一维数组，按顺序列出稀疏矩阵 a 中所有非零元素的值。
// 因 a 由 sprandn2 生成，非零元素个数与数值每次运行都不同。
```
## `spones(s, n)`
声明：function
将稀疏矩阵S中的非零元素替换为n
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------ |
| `s` | array of real | 稀疏矩阵 |
| `n` | real | 非零元素被替换的值，实数 |
返回：array
### 示例
```tsl
// 将S中非零元素替换为1
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return spones(s, 1);
// 输出：
// array(0:
// (1),2:
// (2:1),3:
// (3:1))
```
## `sprand1(s)`
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数
<!-- tags: 创建 生成 -->
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 创建与矩阵S相同结构的稀疏均匀随机矩阵
s := array((0, 0, 3, 0, 0),
(0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(0, 2, 0, 0, 0),
(0, 0, 0, 0, 4));
return sprand1(s);
// 输出：与 S 结构相同(非零位置一致)的稀疏矩阵，非零元素替换为 (0,1) 均匀随机数。
// 非零位置固定，但随机值每次运行都不同。
```
## `sprand2(m, n, pct)`
声明：function
创建m\*n稀疏均匀随机矩阵，其中非零元素所占比例为pct
<!-- tags: 创建 生成 -->
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
| `pct` | real | 矩阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10稀疏均匀随机矩阵
a := sprand2(10, 10, 0.3);
return a;
// 输出：10*10 稀疏矩阵，约 30% 位置非零，非零元素为 (0,1) 均匀随机数。
// 非零位置与数值每次运行都不同。
```
## `sprandn1(s)`
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数
<!-- tags: 创建 生成 -->
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 创建与矩阵S相同结构的稀疏正态随机矩阵
s := array((0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(3, 0, 0, 0, 0),
(0, 0, 2, 0, 0),
(0, 0, 0, 0, 4));
return sprandn1(s);
// 输出：与 S 结构相同(非零位置一致)的稀疏矩阵，非零元素替换为标准正态随机数。
// 非零位置固定，但随机值每次运行都不同。
```
## `sprandn2(m, n, pct)`
声明：function
创建m\*n稀疏正态随机矩阵，其中非零元素所占比例为pct
<!-- tags: 创建 生成 -->
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
| `pct` | real | 矩阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10稀疏正态随机矩阵
a := sprandn2(10, 10, 0.2);
return a;
// 输出：10*10 稀疏矩阵，约 20% 位置非零，非零元素为标准正态随机数。
// 非零位置与数值每次运行都不同。
```
## `sprandsym1(s)`
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵
<!-- tags: 创建 生成 -->
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 创建与矩阵S相同结构的对称稀疏正态随机矩阵
s := array((6, 1, 0, 14, 0),
(0, 7, 0, 0, 15),
(1, 0, 8, 0, 0),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return sprandsym1(s);
// 输出：与 S 相同结构的对称稀疏矩阵，非零元素为正态随机数且关于主对角线对称。
// 非零位置固定，但随机值每次运行都不同。
```
## `sprandsym2(n, pct)`
声明：function
创建n\*n稀疏正态随机矩阵，以下三角矩阵为基准对称正态分布随机矩阵，其中非零元素所占比例大约为pct
<!-- tags: 创建 生成 -->
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `n` | integer | 方阵的尺寸，整数 |
| `pct` | real | 方阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10对称稀疏正态随机矩阵
a := sprandsym2(10, 0.2);
return a;
// 输出：10*10 对称稀疏矩阵，约 20% 位置非零，以下三角为基准对称，非零元素为正态随机数。
// 非零位置与数值每次运行都不同。
```
## `statByColumn(t, fname, _type)`
声明：function
依据Type传递的字符串，返回字段Fname序列的type值
| 参数 | 类型 | 说明 |
| ------- | ------ | ---------------- |
| `t` | array | 数据表类型，数据 |
| `fname` | string | 字符串，字段名称 |
| `_type` | string | 字符串，返回类型 |
返回：any
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return statByColumn(s, 'a', 'MAX');
// 返回a列最大值:5
```
## `stdevByColumn(t, f_name)`
声明：function
指定列的标准差
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return stdevByColumn(t2, 'c');
// 输出：17.08
```
## `stockAmount(t, date, yes_value, change_field, item)`
声明：function
在有序数据表 t 中，按 `change_field` 列定位最后一个不晚于 Date 的行（即 `change_field <= Date` 的最近一行），返回其 `item` 列的值；`yes_value` 决定取该行本身还是其前一行
| 参数 | 类型 | 说明 |
| -------------- | ------- | ------------------------------------------------------------ |
| `t` | array | 数据表类型，按 `change_field` 升序排列的数据表 |
| `date` | integer | 实数或日期，用于与 `change_field` 列比较的基准值 |
| `yes_value` | integer | 布尔值。0：返回命中行（Date 当期）；非 0：返回命中行的前一行 |
| `change_field` | string | 与 Date 比较的列名 |
| `item` | string | 返回值所在的列名 |
返回：any。命中行（或其前一行）中 `item` 列的值；若表中不存在不晚于 Date 的行，返回 0。
### 示例
```tsl
t := array(
("变动日": 20110630, "收盘价": 90),
("变动日": 20120630, "收盘价": 60),
("变动日": 20130530, "收盘价": 33),
("变动日": 20110630, "收盘价": 90),
("变动日": 20130630, "收盘价": 30),
("变动日": 20140630, "收盘价": 20));
r1 := stockAmount(t, 20130630, 0, '变动日', '收盘价'); // Date当期
r2 := stockAmount(t, 20130630, 1, '变动日', '收盘价'); // 命中行的前一行
return array(r1, r2);
// 输出：array(30,90)
```
## `strSubscriptTableToNormal(t, fn)`
声明：function
字符串下标数组-->索引下标数组
| 参数 | 类型 | 说明 |
| ---- | ------ | ---------------------------------------- |
| `t` | array | 二维数组，数据 |
| `fn` | string | 字符串或数值，行标变成数据之后使用的列名 |
返回：array
### 示例
```tsl
data := array("a": (1, 2), "b": (3, 4));
echo trim(toStn(strSubscriptTableToNormal(data, "source_index")));
```
## `sumValueByColumn(t, f_name)`
声明：function
指定列中所有实数的和
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定字段 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return sumValueByColumn(t1, 'b');
// 输出：12
```
## `sumValueByColumn2(tb, column_name, from_row, to_row)`
声明：function
求指定列中指定多行的和
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------------------------- |
| `tb` | array | 数据表 |
| `column_name` | string | 指定字段 |
| `from_row` | integer | 指定计算起始行索引号（从0开始） |
| `to_row` | integer | 指定计算结束行索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByColumn2(t2, 'c', 1, 2);
// 输出：76
```
## `sumValueByRow(tb, row_index)`
声明：function
求指定行的和
| 参数 | 类型 | 说明 |
| ----------- | ------- | --------------------------- |
| `tb` | array | 数据表 |
| `row_index` | integer | 指定计算行索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow(t2, 2);
// 输出：46
```
## `sumValueByRow2(tb, row_index, from_col, to_col)`
声明：function
求指定行中指定多列的和
| 参数 | 类型 | 说明 |
| ----------- | ------- | ------------------------------- |
| `tb` | array | 数据表 |
| `row_index` | integer | 指定计算行索引号（从0开始） |
| `from_col` | integer | 指定计算起始列索引号（从0开始） |
| `to_col` | integer | 指定计算起始列索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow2(t2, 1, 0, 1);
// 输出：36
```
## `tableSelect(table, condition, reps)`
声明：function
表格查询。从t中查询满足Condition的子表
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------ |
| `table` | any | 数据表 |
| `condition` | string | 字符串 |
| `reps` | string | 字符串 |
返回：array
### 示例
```tsl
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return tableSelect(t, "~['b']=2", '~'); // 返回 t 中字段 'b'=2 的子表
// 输出：
```
## `tableVectorizeArray(t, s, opt, is_func)`
声明：function
数据表与一维数据表的矢量化运算
| 参数 | 类型 | 说明 |
| --------- | ----------- | -------------------------------------- |
| `t` | array | 数据表 |
| `s` | array\|real | 一维数组 或实数， 运算标量 |
| `opt` | string | 字符串，操作运算符，默认"-",表逐行减法 |
| `is_func` | bool | 布尔，opt是否是函数，默认假 |
返回：array
### 示例
```tsl
t := ones(10, 3);
s := array(1, 2, 3);
return tableVectorizeArray(t, s, '-');
// 输出：
// array(
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2))
```
## `TwoRDateCompare_M1(t1, t2, r_date, r_date2, key_field, from_col, to_col, show_g_value, show_g_percent)`
声明：function
返回2个数据同比比较的结果
<!-- tags: 返回 获取 -->
| 参数 | 类型 | 说明 |
| ---------------- | -------- | -------------------------- |
| `t1` | array | 数组类型，数据1 |
| `t2` | array | 数组类型，数据2 |
| `r_date` | datetime | 报告期类型，报告期 |
| `r_date2` | any | 报告期类型，同比报告期 |
| `key_field` | string | 字符串类型，关键字 |
| `from_col` | any | 整型，要显示变比的开始列号 |
| `to_col` | any | 整型，要显示变比的截止列号 |
| `show_g_value` | bool | 布尔类型，显示变动 |
| `show_g_percent` | bool | 布尔类型，显示变比(%) |
返回：array
### 示例
```tsl
current_data := array(("code": "A", "value": 120));
previous_data := array(("code": "A", "value": 100));
echo trim(toStn(TwoRDateCompare_M1(
current_data,
previous_data,
20220331,
20210331,
"code",
0,
0,
true,
true
)));
```
## `unitary(t, key_fields, _type, f_value)`
声明：function
归一处理。对数组t指定列KeyFields进行归一处理，归一方式由Type决定
| 参数 | 类型 | 说明 |
| ------------ | ---------------- | ---- |
| `t` | array,tablearray | |
| `key_fields` | string | |
| `_type` | integer | |
| `f_value` | integer | |
返回：array,tablearray
### 示例
```tsl
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
unitary(t, 'b', 0, 10);
return t;
// 输出：
// array(
// ("a":1,"b":10.0,"c":3,"d":4,"e":5,"f":7),
// ("a":2,"b":15.0,"c":4,"d":5,"e":6,"f":8),
// ("a":3,"b":20.0,"c":5,"d":6,"e":7,"f":9),
// ("a":4,"b":25.0,"c":6,"d":7,"e":8,"f":10))
```
## `varByColumn(t, f_name)`
声明：function
指定列的方差
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return varByColumn(t2, 'c');
// 输出：291.67
```
## `zValue(t, column_name)`
声明：function
按照指定字段求Z值
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------------ |
| `t` | array | 数据表类型，数据表 |
| `column_name` | string | 字符串，要计算Rank的字段 |
返回：any
### 示例
```tsl
s := array(
("代码":"SZ000001", "名称":"平安银行", "收盘":11.2, "涨幅(%)":0.900900900900892),
("代码":"SZ000002", "名称":"万 科Ａ", "收盘":27.68, "涨幅(%)":-0.25225225225225),
("代码":"SH600000", "名称":"浦发银行", "收盘":10.77, "涨幅(%)":0.372786579683115),
("代码":"SH600100", "名称":"同方股份", "收盘":8.73, "涨幅(%)":1.74825174825175));
zValue(s, '涨幅(%)');
return s;
// 输出：
// array(
// ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892,"Z_涨幅(%)":0.246104637421774),
// ("代码":"SZ000002","名称":"万 科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225,"Z_涨幅(%)":-1.11516496413374),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115,"Z_涨幅(%)":-0.37732163484235),
// ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175,"Z_涨幅(%)":1.24638196155432))
```
Reference in New Issue View Git Blame Copy Permalink