csh/playbook
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c6895fe41a889e2c60fd9720d8105f3947b7e9b8
playbook/skills/tsl-api-reference/references/codegen/dotnet/runtime/array.md
T
csh 1f19954dd7 ♻️ refactor(tsl-api-reference): reorganize function reference pages 
Move runtime and document pages into their correct scope, remove obsolete pending entries, and regenerate the function index.\nUpdate agent test guidance and API skill routing to match the new reference layout.
2026-07-20 09:08:38 +08:00

3601 lines
112 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.
# 运行时 / 数组
## 数组 / 基础函数
## `callInArray(func, args)`
以参数数组调用指定函数（含函数名或函数变量）。
| 参数 | 类型 | 说明 |
| ------ | ------ | ---------------------- |
| `func` | string | 函数名字符串或函数指针 |
| `args` | array | 参数数组 |
返回：any
## `deleteField(arr, index, merge)`
数组相关函数。
| 参数 | 类型 | 说明 |
| ------- | ----- | ---- |
| `arr` | array | |
| `index` | any | |
| `merge` | bool | |
返回：bool
## `deleteIndex(arr, index, merge)`
数组相关函数。
| 参数 | 类型 | 说明 |
| ------- | ----- | ---- |
| `arr` | array | |
| `index` | any | |
| `merge` | bool | |
返回：bool
## `execSql(flags, _params, data_base_name, sql, data_keep_null)`
执行SQL语句，该函数总共有8个参数，其中，Flags、Params、UserName;Password、DataKeepNull为可选参数，在调用时，注意参数顺序按定义中的顺序来传入，不需要的参数可以跳过不给。 比如只给Params这个可选参数，则调用代码为： param:=array("TestParamName":("Value":"ParamNameValue","Direction":3)); execsql(param,"test","myStoredProctest",result); 此外，在以上基础上，如果执行的是存贮过程，需要将参数带入，则插入一个参数在最前面，类型为数组，具体结构见参数说明。 如果数据库别名配置在本地，对本地的数据进行操作，则在调用execsql之前，需要加入rdo2关键字（见范例）；如果数据库别名配置在服务器，则不需要rdo2关键字。 ExecSQL允许当别名为WideString的时候，默认使用WideString。
| 参数 | 类型 | 说明 |
| ---------------- | ------ | --------------------------------------------------------------------------------------------------------------- |
| `flags` | int | 功能标识符，可选参数，设置值如下 |
| `_params` | array | 数组类型，可选参数，以存贮过程的参数名为下标的一个数组描述存贮过程的参数，其每个存贮参数下标指向的值的结构如下: |
| `data_base_name` | string | 字符串类型，数据库别名，用于指定数据库名称；例如\[SQLAlias\]，配置方法详见数据库配置。 |
| `sql` | array | 字符串类型，需要执行的SQL语句。 |
| `data_keep_null` | string | object |
返回：Interger
## `exportJsonStringUtf8(data, n, return_value)`
将天软数组转换为UTF8编码的Json串，解决与第三方交互时的转码问题。
| 参数 | 类型 | 说明 |
| -------------- | ------- | ----------------------------------------------------------------------------- |
| `data` | anytype | 天软数据，任意数据类型。 |
| `n` | int | 可选参数，要保留的小数位数。为0时保留1位小数，大于16或小于0时保留全部小数位数 |
| `return_value` | string | 字符串，UTF8编码的Json字符串。 |
返回：string
## `getMatrixFields(matrix)`
获取 Matrix 的字段（列名）列表。
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------- |
| `matrix` | matrix | Matrix 数据 |
返回：array
## `invokeinarray(obj, member_name, member_value, _params)`
调用类的成员方法或对类的成员变量进行赋值操作。支持对重载方法的调用。基本功能与invoke一样，区别在于设置成员变量的值与调用成员方法的参数值通过数组进行传递。另外，支持命名参数的调用。
| 参数 | 类型 | 说明 |
| -------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `obj` | TSLObject | 实例对象 |
| `member_name` | string | 字符串(小写)，成员(方法或属性)的名称 |
| `member_value` | bool | object |
| `_params` | array | 数组，若是成员属性则数组传递的是设置的成员属性值，若是成员方法则表示成员方法的参数，成员方法没有参数时须初始化为空数组。命名参数调用时，下标字符串作为参数名。 |
返回：any
## `magicGetArray(arr, n1, n2, nn)`
获取数组指定下标的值，支持多维数组。中间的参数可以是直接列出的数组各维下标，也可以以数组的形式表现，数组内的数据就是下标。
| 参数 | 类型 | 说明 |
| ----- | ------ | -------- |
| `arr` | array | 数组 |
| `n1` | string | string\\ |
| `n2` | string | string |
| `nn` | string | string |
返回：any
## 数组 / 排序函数
## `magicSetArray(arr, n1, n2, nn, a)`
对数组进行操作，对数组指定下标的数据进行赋值，支持多维数组。中间的参数可以是直接列出的数组各维下标，也可以以数组的形式表现，数组内的数据就是下标。
| 参数 | 类型 | 说明 |
| ----- | ------ | -------------------------------- |
| `arr` | array | 数组 |
| `n1` | string | string\\ |
| `n2` | string | string |
| `nn` | any | string |
| `a` | string | 最后一个参数，任意值，被赋的值。 |
返回：array
## `matrixToArray(mat)`
转换一个Matrix类型为Array。主要可用于Matlab 与TS交互时，从MatLab中得到的矩阵，在TS中不能进行矩阵操作，将Matrix转为天软的矩阵类型之后，即可进行矩阵计算等操作。 如果要反向转换（把Array转化成Matrix），可以采用mselect语法。 支持fmarray转换成Array数组，比如MatrixToArray(fmarray\[1,2,3\])返回array(1,2,3)。
| 参数 | 类型 | 说明 |
| ----- | ------ | --------------------------------- |
| `mat` | matrix | Martrix类型，要转换的MARTIX数据。 |
返回：array
## `reIndex(data, index_info1, index_info2, index_info_n)`
修改数组下标
| 参数 | 类型 | 说明 |
| -------------- | ----- | -------------- |
| `data` | array | 需要重构的数组 |
| `index_info1` | any | Array |
| `index_info2` | any | Array |
| `index_info_n` | any | Array |
返回：array
## `reshape(a, count1, count_n)`
将原数组A的元素重构为一个新的指定行列大小的数组，支持行列重命名。要求重构后的数组的元素个数与原数组的元素个数保持一致。 当只有一个参数时，将原数组A重构为一个一维数组，当有多个参数时，重构为指定结构的N维数组。
| 参数 | 类型 | 说明 |
| --------- | ----- | ---------------------------------------------------------------------------------------------------- |
| `a` | array | 数组类型，需要重构的数组。 |
| `count1` | array | 整数或数组类型，重构的第一维的长度或下标，可缺省，其值可以为第一维度的长度，也可以是维度的下标数组。 |
| `count_n` | array | 整数或数组类型，重构的第N维的长度或下标，可缺省，其值可以为第N维度的长度，也可以是维度的下标数组。 |
返回：array
## 数据表与数组扩展函数
## `istable(t)`
判断是否为数组。如果t为数据表，返回True；否则，返回False
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：bool
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return istable(t1);
// 结果：1
```
## `noRecordTable()`
返回一个空数组
返回：array,tablearray
### 示例
```tsl
return noRecordTable();
// 结果：Array()
```
## `getSubTable(table, field_arr)`
将一个表类型数组只保留指定的字段并返回
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------- |
| `table` | array | 二维数组 |
| `field_arr` | array | 列标名，一维数组 |
返回：array
### 示例
```tsl
a := array((1, 2, 4), (11, 12, 14));
b := array(0, 2);
return getSubTable(a, b);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:getSubTable compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```
## `fieldCount(t)`
数据表字段个数。如果t不是一个数据表，则返回0
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldCount(t1);
// 结果：2
```
## `fieldExist(t, f_name)`
指定字段是否存在。如果存在，则返回索引号；(索引号从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
```
## `fieldNames(t)`
返回数据表所有字段名称
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));return fieldNames(t1);
// 输出：
// 示例未提供可直接输出的返回表达式。
```
## `fieldName(t, field_index)`
返回数据表指定列索引号（索引号从0开始）的字段名称
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------ |
| `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’
```
## `recordExist(t, v)`
数值是否在数组中存在（一维数组），如果存在，则返回索引号；(索引号从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)`
记录数据表（二维数组）中是否存在列名为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)`
记录指定值是否存在一维数组中，如果存在，返回1，不存在，返回0
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------- |
| `v` | string | 指定数组，一维数组 |
| `x` | integer | 指定值，与v单元值类型一致 |
返回：bool
### 示例
```tsl
t := array(1, 2, 12, 3, 14);
return recordExist3(t, 3);
// 结果：1
```
## `passwordGen(len, n, head, start)`
密码生成器
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------ |
| `len` | integer | 整数，密码长度 |
| `n` | integer | 整数，生成的密码组合数 |
| `head` | string | 字符串，用户名的前缀 |
| `start` | integer | 整数，用户名的后缀序列数字的起始数字 |
返回：array
### 示例
```tsl
return rdo2 passwordGen(8, 5, 'ts', 3);
// 返回:
```
## `appendArray(arr, con)`
数组新增元素，给数组arr添加一项con
| 参数 | 类型 | 说明 |
| ----- | ------- | ------------------------ |
| `arr` | array | 一维数组 |
| `con` | integer | 整数或字符串，需增加的值 |
返回：array
### 示例
```tsl
a := array(1, 2, 3);
appendArray(a, 4);
return a;
// 返回:
```
## `in1(v, x)`
判断数值x是否在数组v中，返回布尔类型
| 参数 | 类型 | 说明 |
| ---- | ----- | -------- |
| `v` | array | 一维数组 |
| `x` | real | 实数 |
返回：bool
### 示例
```tsl
a := array(1, 2, 3, 4);
return in1(a, 3);
// 结果：1
```
## `deleteColumnByField(t, fields)`
删除指定列，可以一次性删除多列，删除的列字段之间使用；分割
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------------------------ |
| `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');
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:deleteColumnByField compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `getValuesByFieldValue(t, f_name, field_value)`
返回指定字段值等于指定值的所有记录
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------- |
| `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的所有记录
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```
## `seekPosInArray(r, arr)`
数字定位，采用二分法寻找数字R在一位正序数字数组arr中的下标。
| 参数 | 类型 | 说明 |
| ----- | ----- | ------------ |
| `r` | real | 实数 |
| `arr` | array | 一维数字数组 |
返回：integer
### 示例
```tsl
return seekPosInArray(4, array(1, 2, 3, 4, 5));
// 返回：3
```
## `outPutTableToCanBeUnderstood(t)`
判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组。
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------- |
| `t` | array | 数组，数据表。 |
返回：string|array
### 示例
```tsl
return outPutTableToCanBeUnderstood(array(1, 2, 3));
// 返回:
```
## `filterOneDimEx2(t, v1)`
小于等于指定值的最后一条记录(一维数组)。
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `t` | array | 一维数字数组 |
| `v1` | real | 实数，指定值 |
返回：real
### 示例
```tsl
s := array(1, 2, 3, 4, 5, 6);
return filterOneDimEx2(s, 4);
// 返回：4
```
## `groupByFieldValue(t, group_field, lowvalue, high_value, sep_value)`
按字段大小进行汇总。小于最小值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);
// 返回:
```
## `columnValue(t, fname)`
取得指定列的所有值(按列名)。该函数的功能与直接用读取子矩阵的方式一样，但是用子矩阵的方式更简单快速。功能相当于t[:,fname]
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------ |
| `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, '收盘');
// 返回:
```
## `filterTableEx(t, fname, method, v1, v2)`
范围取值，从一个表中按照某个字段的取值范围返回对应的记录
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------------------------- |
| `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
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```
## `getBottomN(t, n)`
取数组后N行，一般先用SortByField排序，然后使用此函数
| 参数 | 类型 | 说明 |
| ---- | ------- | ------ |
| `t` | array | 数据表 |
| `n` | integer | 整数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getBottomN(t2, 2);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:getBottomN compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `getMiddleN(t, from_no, to_no)`
取数组指定行区间记录，一般先用SortByField排序，然后使用此函数
| 参数 | 类型 | 说明 |
| --------- | ------- | ---------------------- |
| `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);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:getMiddleN compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `getTopN(t, n)`
取数组前N行记录，一般先用SortByField排序，然后使用此函数
| 参数 | 类型 | 说明 |
| ---- | ------- | ------ |
| `t` | array | 数据表 |
| `n` | integer | 整数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getTopN(t2, 2);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:getTopN compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `filterOneDimEx(t, method, v1, v2)`
范围取值（一维数组）从一个一维数组中按照取值范围返回对应的记录。
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------------------------- |
| `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);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:filterOneDimEx compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `getDistinctValue(t, f_name)`
得到指定列唯一值，返回值为一维数组
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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');
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:getDistinctValue compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `columnValue2(t, column_name)`
取得多个指定列的所有记录
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------------ |
| `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');
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:columnValue2 compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `filterTable(t, v)`
从指标表中取以下列的值为v的数据：
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------ |
| `t` | array | 数组类型，数据 |
| `v` | integer | 报告期类型，报告期 |
返回：array
### 示例
```tsl
// 'SZ002664'在20211231时的分红送股数据
setSysParam(pn_stock(), 'SZ002664');
return filterTable(infoArray(18), 20211231);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:infoArray compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```
## `getSubField(t, field)`
取表中某一字段的全部列值
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------- |
| `t` | array | 二维数组 |
| `field` | string | 列标名，字符串/整数 |
返回：array
### 示例
```tsl
a := array(('a': 8, 'b': 7), ('a': 6, 'b': 9));
return getSubField(a, 'a'); // 从a表中取第’a列’
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```
## `mergeArray(v1, v2, ...)`
多个数组进行合并
| 参数 | 类型 | 说明 |
| ----- | ----- | ---- |
| `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合并
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```
## `intersectionPart(v, w)`
求交集
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `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);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:intersectionPart compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```
## `quickIntersectionPart(v, w)`
快速求交集
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `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);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:intersectionPart compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```
## `distinctStr(t)`
去掉序列中的重复元素
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------- |
| `t` | array | 一维字符串/数字数组 |
返回：array
### 示例
```tsl
a := array('w', 'd', 'f', 'd', 'e');
return distinctStr(a); // 保留不相同的，相同的只保留一个
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```
## `sumValueByColumn(t, f_name)`
指定列中所有实数的和
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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)`
求指定列中指定多行的和
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------------------------- |
| `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)`
求指定行的和
| 参数 | 类型 | 说明 |
| ----------- | ------- | --------------------------- |
| `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)`
求指定行中指定多列的和
| 参数 | 类型 | 说明 |
| ----------- | ------- | ------------------------------- |
| `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
```
## `maxValueByColumn(t, f_name)`
求指定列中的最大值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `minValueByColumn(t, f_name)`
求指定中的最小值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `averageValueByColumn(t, f_name, from_row, to_row)`
求在指定多行中指定列的平均值
| 参数 | 类型 | 说明 |
| ---------- | ------- | --------------------------- |
| `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
```
## `renameField(t, old_field, new_field)`
修改指定字段的名称
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------- |
| `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
```
## `normalTabletoStrSubscript(t, key_field)`
索引下标数组-->字符串下标数组。将keyfield列的值变为行标。
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------ |
| `t` | array | 数据表类型 |
| `key_field` | string | 字符串，列名 |
返回：any
### 示例
```tsl
s := nDay(10, 'time', dateToStr(sp_time()), 'close', close());
return normalTabletoStrSubscript(s, 'time');
// 把 time列的数据变为行标
---变为--》
```
## `show3DTable(t, key_field, obsolete_fields, ntype)`
特殊函数，平台功能性函数，一般用户不使用。用于三维表格显示格式转换，其中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);
// 返回:
```
## `show2DTable(t, key_field, obsolete_fields, ntype)`
特殊函数，平台功能性函数，一般用户不使用。二位表格显示格式转换，其中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);
// 返回:
```
## `showTableByField(t, field_arr)`
显示数据表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)`
数据表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);
// 返回:
```
## `quickRecordExist(v, x)`
记录是否存在(原数组若为纯字符串数组则必须为有序列)，返回记录所在行的序号，序号是从0开始原数组必须为有序表
| 参数 | 类型 | 说明 |
| ---- | ------ | ----------- |
| `v` | array | 一维数组 |
| `x` | string | 字符串/数字 |
返回：integer
### 示例
```tsl
t := array('a', 'c', 'd');
return quickRecordExist(t, 'd');
// 结果：2
```
## `rotateTable(data)`
旋转表
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------------- |
| `data` | array | 数据表，二维数组 |
返回：array
### 示例
```tsl
t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return rotateTable(t);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:rotateTable compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```
## `footerValue(t, from_col, tocol, average_col_field, _type)`
数组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);
// 返回:
```
## `footerAverage(t, from_col, tocol, average_col_field)`
调用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)`
调用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, '');
// 返回:
```
## `setRowDefaultValue(t, n, value)`
将数组t的第N行由所有值变更为Value。
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------ |
| `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;
// 返回:
```
## `inverseTable(t)`
将数组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);
// 返回:
```
## `tableSelect(table, condition, reps)`
表格查询。从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的子表
// 返回:
```
## `getSubTableFreeParam()`
取子表，系统第二个到最个一个参数为字段序列，取第一个参数中字段与字段序列匹配的列数据。
返回：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’。
// 返回:
```
## 数据表 / frame、稀疏矩阵与统计函数（由 base 迁入）
## `fieldNamesOfStrSubscript(t)`
字符串下标数组的字段名称。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `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);
// 返回:
```
## `fieldCountOfStrSubscript(t)`
字符串下标数组的字段个数。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `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
```
## `argmax(x)`
1、返回一维数组中最大值所在下标
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ------------ |
| `x` | array,tablearray | 一维数字数组 |
返回：integer
### 示例
```tsl
x := array(9, 8, 10);
return argmax(x); // 2
```
## `argmin(x)`
1、返回一维数组中最小值所在下标
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ------------ |
| `x` | array,tablearray | 一维数字数组 |
返回：integer
### 示例
```tsl
x := array(3, 1, 9, 2);
return argmin(x); // 1
```
## `sortTableByFieldExt(t, sort_field)`
将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并。
| 参数 | 类型 | 说明 |
| ------------ | ------ | ---------------- |
| `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');
// 返回:
```
## `rankValue(t, fields)`
按照指定字段求Rank,返回的数据，保存在传递过来的数据t中。返回按Fields列排序的结果，
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------ |
| `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))
```
## `argsort(value, sortdir)`
返回可以用于排序的一维数组下标
| 参数 | 类型 | 说明 |
| --------- | ------- | --------------------------------------- |
| `value` | array | 一维数字数组，数组 |
| `sortdir` | integer | 整数，排序方向（1:正序【默认】;0:逆序） |
返回：array
### 示例
```tsl
value := array(4, 8, 2, 3, 9);
return argsort(value); // 返回：array(2,3,0,1,4)
```
## `rankIt(t, f_n, sort_order)`
按指定字段的值排名；SortOrder：0 降序排名；SortOrder：1升序排名
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `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)`
按指定字段的值排名，SortOrder:0 降序排名；SortOrder:1 升序排名，排名列的字段为：OfN
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `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))
```
## `rpsIt(t, f_n, sort_order)`
按指定字段的值排名，获得其排名的百分位，排序百分位放在列 FN+"\_RPS"中；
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `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))
```
## `deleteNilValueByField(t, fields)`
删除指定字段fields数据为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))
```
## `inserttablebyrno(t, index, rdata)`
向表格指定位置插入行，天软表格行下标从0开始
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------------------------------ |
| `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)
```
范例2：
```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"))
```
## `arrayextend(a, ind, v)`
数组-指定位置插入子集
| 参数 | 类型 | 说明 |
| ----- | --------------- | ---------------------------- |
| `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")
```
## `arrayinsert(a, ind, v)`
数组-指定位置插入值
| 参数 | 类型 | 说明 |
| ----- | --------------- | ---------------------------- |
| `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")
```
## `frameinsert(data, loc, fname, v)`
数据表-指定位置插入列
| 参数 | 类型 | 说明 |
| ------- | ------- | ----------------------- |
| `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))
```
## `searchsorted(v, x)`
有序列表插入指定值的位置，原数组必须为有序表且元素应可比较。
| 参数 | 类型 | 说明 |
| ---- | -------------- | ----------------- |
| `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
```
## `argconfirst(a, v, _type)`
第一次满足条件的位置, 原数组必须为有序表且元素应可比较。
| 参数 | 类型 | 说明 |
| ------- | ------------------- | -------- |
| `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
```
## `stockAmount(t, date, yes_value, change_field, item)`
在有序数据表 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)
```
## `seperateTable(t, sep_field, sep_count)`
把表格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)))
```
## `unitary(t, key_fields, _type, f_value)`
归一处理。对数组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))
```
## `tableVectorizeArray(t, s, opt, is_func)`
数据表与一维数据表的矢量化运算。
| 参数 | 类型 | 说明 |
| --------- | ----------- | -------------------------------------- |
| `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))
```
## `reverse(arr)`
数组倒置反向。
| 参数 | 类型 | 说明 |
| ----- | ----- | ---- |
| `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))
```
## `descartesJoin(v1, v2, v_n)`
数组笛卡尔积连接。
| 参数 | 类型 | 说明 |
| ----- | ---- | --------------------------------- |
| `v1` | | 任意类型，支持不定个数参数，数值1 |
| `v2` | | 任意类型，数值2 |
| `v_n` | | 任意类型，数值3 |
返回：array,tablearray
### 示例
```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))
```
## `abnormalData(y, flag, ystore)`
数组中出现奇异值的处理。其中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是修改后的值
```
## `zValue(t, column_name)`
按照指定字段求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))
```
## `rpsValue(t, column_name)`
按照指定字段求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))
```
## `webFormatToRung(a)`
将数组Nan/Nil/±Inf替换为"-"
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------------------------- |
| `a` | array | 数组，待替换数组，支持多维数组，高维嵌套数组 |
返回：any
### 示例
```tsl
a := array('a': ('b': ('c': (nil, nan, 3), 'd': 2), 'e': nan));
return webFormatToRung(a); // array("a":("b":("c":("-","-",3),"d":2),"e":"-"))
```
## `factorize(value, ifsort, nan_fill_value, uniques)`
分类变量数值映射，将一个一维分类变量数组映射为给分类变量递增编号后的数值数组
| 参数 | 类型 | 说明 |
| ---------------- | ----- | ---------------------------------- |
| `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);
```
## `sparseMatFill(a, fillv)`
稀疏数据表填充，直接在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))
```
## `elementWhere(con, x, y)`
根据布尔数组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)
```
## `arrayAddGap(t, key, v, m)`
数组添加分割线,只支持字符串下标
| 参数 | 类型 | 说明 |
| ----- | ------- | ------------------------------------------- |
| `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)
```
## `groupPercentrankIt(t, g_name, v_name)`
计算分组百分位，对数据表t按[GName]分组后，对每组的[Vname_]计算百分位
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------ |
| `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)`
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]计算排名
| 参数 | 类型 | 说明 |
| ------------ | ------ | ------------------ |
| `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)`
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]根据给定函数进行分组转换操作
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------------------------------------------- |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串或数组，转换字段名 |
| `fp` | 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));
fp := function (v, g);
begin
return rankof([v], [v]);
end
return groupTransformByFunc(t, 'G', 'V1', fp); // array(3,3,2,2,1,1)
```
## `frameGetSubByReg(data, reg)`
通过正则表达式匹配获取数据框子集
| 参数 | 类型 | 说明 |
| ------ | ------ | -------------------------- |
| `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))
```
## `histogram(t, bins, format)`
统计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@频数 …… 等列。区间划分固定，但各频数因随机样本每次运行都不同。
```
## `framemerge(left, right, ons, how)`
数据表-联结
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------- |
| `left` | table | Table,左表 |
| `right` | table | Table,右表 |
| `ons` | string | String,联结字段，可以为数组 |
| `how` | string | String,: 联结类型 |
返回：array
### 示例
范例1：
```tsl
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
return framemerge(left, right, 'a');
// 输出：内连接，仅保留两表 a 均匹配的行(a=3,4)，重名列 a、b 加 _x/_y 后缀区分。
// array(
// ("a_x":3,"b_x":0.1,"a_y":3,"b_y":0.7,"c":30),
// ("a_x":4,"b_x":0.2,"a_y":4,"b_y":0.8,"c":40))
```
范例2
```tsl
// 多字段merge
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
left[: , 'c'] := left[: , 'a'];
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
right[: , 'c'] := right[: , 'a'];
names := array('a', 'c');
return framemerge(left, right, names, 'left', nil, true);
// 输出：按 a、c 两字段做左连接(how='left')，保留左表全部行(a=3,4,5)，重名列加 _x/_y 后缀。
// array(
// ("a_x":3,"b_x":0.1,"c_x":3,"a_y":3,"b_y":0.7,"c_y":3),
// ("a_x":4,"b_x":0.2,"c_x":4,"a_y":4,"b_y":0.8,"c_y":4),
// ("a_x":5,"b_x":0.3,"c_x":5))
```
范例3
```tsl
// 只更名right
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
return framemerge(left, right, 'a', 'full', array(nil, '_x'));
// 输出：全外连接(how='full')，保留两表所有 a；仅右表重名列加 '_x' 后缀(左表列名不变)。
// array(
// ("a":3,"b":0.1,"a_x":3,"b_x":0.7,"c":30),
// ("a":4,"b":0.2,"a_x":4,"b_x":0.8,"c":40),
// ("a":5,"b":0.3),
// ("a_x":1,"b_x":0.5,"c":10),
// ("a_x":2,"b_x":0.6,"c":20))
```
## `frameqcut(data, q)`
数据表-按频率分组(等频分组)
| 参数 | 类型 | 说明 |
| ------ | ------- | -------------------------------------------- |
| `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)
```
## `frameupdate(left, right, ons, _type, _type)`
数据表-更新
| 参数 | 类型 | 说明 |
| ------- | ------- | -------------------------------------------- |
| `left` | table | Table,待更新数据，直接更改 |
| `right` | table | Table,右表 |
| `ons` | string | String,键字段，默认为nil，表以下标进行联结。 |
| `_type` | integer | Integer,缺失类型，详见MF_isMissValue |
| `_type` | integer | 为以下数值的组合(以下数值的\_XOR或者相加) |
返回：array
### 示例
```tsl
left := `array('a': 3->5, 'b': rand(3));
right := `array('a': 1->4, 'b': rand(4), 'c': rand(4) * 10);
return frameupdate(left, right, 'a');
```
## `groupZscoreIt(t, g_name, v_name)`
1.计算分组标准化，对数据表t按[GName]分组后，对每组的[Vname_]进行标准化(原值-分组平均)/分组标准差
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
| `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)
```
## `framecut(a, bins, option, o_lables)`
从小到大分段分组，最小的为第0组
| 参数 | 类型 | 说明 |
| ---------- | ------- | --------------------------------------------------------------------------- |
| `a` | array | 数据表或一维数字数组，数据表时，表示对每列分别操作 |
| `bins` | array | 一维数字数组，分段节点，例如array(0,1)将数组a分为[-inf,0)[0,1)[1,inf)三段， |
| `option` | integer | 整型，区间开/闭，默认为0 |
| `o_lables` | integer | 数组，输出分组区间说明 |
返回：array
### 示例
范例1：
```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)
```
## `frameMelt(t, id_names, value_names, variable_sname, value_sname)`
二维表——>立体表
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ------------------------------------------------------------------- |
| `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, '代码', '得分');
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```
## `groupDemeanIt(t, g_name, v_name)`
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))
```
## `arrDropDuplicate(data)`
数组去重(包含NAN)。
| 参数 | 类型 | 说明 |
| ------ | ----- | -------------------- |
| `data` | array | 数据表类型。数据表。 |
返回：array
### 示例
```tsl
data := array(("A": 1, "B": nan), ("A": 1, "B": 2), ("A": 1, "B": nan), ("A": 1, "B": 2));
return arrDropDuplicate(data);
// 结果：array(("A":1,"B":NAN),("A":1,"B":2))
```
## `getSubTableByField(t)`
获取表t中的Fields 列的数据。该函数功能可以用子矩阵的方式实现:t[:,array(fn1,fn2...)]
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------ |
| `t` | array | 数据表类型，数据表 |
返回：any
### 示例
```tsl
r := array(
("time":"2026-07-03","close":10.29,"open":10.29,"high":10.4),
("time":"2026-07-06","close":10.5,"open":10.25,"high":10.52),
("time":"2026-07-07","close":10.47,"open":10.46,"high":10.51),
("time":"2026-07-08","close":10.6,"open":10.44,"high":10.63),
("time":"2026-07-09","close":10.49,"open":10.55,"high":10.59));
return getSubTableByField(r, 'time;close');
// 功能相当于使用子矩阵取数：r[: , array('time', 'close')]
// 返回:
// array(
// ("time":"2026-07-03","close":10.29),
// ("time":"2026-07-06","close":10.5),
// ("time":"2026-07-07","close":10.47),
// ("time":"2026-07-08","close":10.6),
// ("time":"2026-07-09","close":10.49))
```
## `arraygetdefault(r, k, v)`
带默认值的数组取值，取指定下标的值，若存在则返回，否则返回设定的默认值
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `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
```
## `arraysetdefault(r, k, v)`
带默认值的数组赋值(字段未使用则赋值)
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `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)`
带默认值的数组赋值(值为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)
```
## `randomchoice(avalues, size, replace)`
随机抽样
| 参数 | 类型 | 说明 |
| --------- | --------------- | ---------------------------------------- |
| `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 中抽样，返回浮点下标数组。
```
## `filterIntersectionPart(t1, t2, f_name, method)`
求两个数组在指定列名上的差集、交集、并集
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------------------------------------------- |
| `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)`
求两个数组的差集、交集、并集。只适用一维数组。
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------------------------------------------- |
| `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)。
```
## `averageByColumn(t, f_name)`
求指定列的平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `harMeanByColumn(t, f_name)`
指定列的调和平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `geoMeanByColumn(t, f_name)`
指定列的几何平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `devsqByColumn(t, f_name)`
指定列平均值偏差的平方和
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `kurtByColumn(t, f_name)`
指定列的峰度
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `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
```
## `medianByColumn(t, f_name)`
指定列的中位数
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `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
```
## `skewByColumn(t, f_name)`
指定列的偏度
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `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
```
## `stdevByColumn(t, f_name)`
指定列的标准差
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `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
```
## `varByColumn(t, f_name)`
指定列的方差
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `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
```
## `aveDevByColumn(t, f_name)`
指定列与平均值的绝对偏差的平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `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
```
## `percentValueByField(t, key_field, quart)`
数据集在指定百分位数上对应的数值
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------- |
| `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
```
## `statByColumn(t, fname, _type)`
依据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
```
## `describe(data, percentiles)`
简单描述统计
| 参数 | 类型 | 说明 |
| ------------- | --------------- | ---------------------------------------------------- |
| `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);
```
## `framecorrel(data)`
数据表-相关系数矩阵
| 参数 | 类型 | 说明 |
| ------ | ----- | ----------------------------------------------- |
| `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)`
数据表-协方差
| 参数 | 类型 | 说明 |
| ------ | ----- | ------------------------------------------------ |
| `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);
```
## `framehhi(data)`
数据表-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
```
## `framevaluecounts(data, countfieldname, iforder)`
数据表-计数
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ------------------------------------ |
| `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))
```
## `simpledescribe(data)`
简单描述统计
| 参数 | 类型 | 说明 |
| ------ | --------------- | ----------------------------------------------------- |
| `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))
```
## `renameFieldByFormat(t, ifcopy)`
通过格式字符串修改列名。
| 参数 | 类型 | 说明 |
| -------- | ----- | -------------------------------------------- |
| `t` | array | 数组类型，数据 |
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
// 给随机数组批量加后缀
t := rand(10, 10);
suffix := '%s'$"@A";
ifcopy := true;
return renameFieldByFormat(t, suffix, ifcopy);
// 输出：把 10 列随机表的列名 0,1,…,9 按格式 '%s'$"@A" 批量改为 0@A,1@A,…,9@A。
// 列名重命名固定，但因 t 由 rand 生成，各单元格数值每次运行都不同。
```
## `sparse1(s, a, m, n)`
挤出任何非零元素，将满矩阵转化为稀疏格式，与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)`
根据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))
```
## `speye(m)`
创建m\*m稀疏单位矩阵，指定为方阵
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------ |
| `m` | integer | 稀疏单位矩阵的尺寸，整数 |
返回：array
### 示例
```tsl
// 创建m*m稀疏单位矩阵
a := speye(4);
return a;
// 输出：
// array(
// (1),
// (1:1),
// (2:1),
// (3:1))
```
## `sprand1(s)`
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `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)`
创建m\*n稀疏均匀随机矩阵，其中非零元素所占比例为pct
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `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)`
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `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)`
创建m\*n稀疏正态随机矩阵，其中非零元素所占比例为pct
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
| `pct` | real | 矩阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10稀疏正态随机矩阵
a := sprandn2(10, 10, 0.2);
return a;
// 输出：10*10 稀疏矩阵，约 20% 位置非零，非零元素为标准正态随机数。
// 非零位置与数值每次运行都不同。
```
## `sprandsym1(s)`
创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `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)`
创建n\*n稀疏正态随机矩阵，以下三角矩阵为基准对称正态分布随机矩阵，其中非零元素所占比例大约为pct
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `n` | integer | 方阵的尺寸，整数 |
| `pct` | real | 方阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10对称稀疏正态随机矩阵
a := sprandsym2(10, 0.2);
return a;
// 输出：10*10 对称稀疏矩阵，约 20% 位置非零，以下三角为基准对称，非零元素为正态随机数。
// 非零位置与数值每次运行都不同。
```
## `sparsefull(s, m, n)`
将稀疏矩阵格式转化为满矩阵，与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))
```
## `spones(s, n)`
将稀疏矩阵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))
```
## `spnnz(s)`
稀疏矩阵S中的非零元素数目
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：integer
### 示例
```tsl
// 稀疏正态随机矩阵A中非零元素数目
a := sprandn2(5, 5, 0.2);
return spnnz(a); // 返回4（随机）
```
## `spnonzeros(s)`
提取稀疏矩阵S中的非零元素
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 提取稀疏正态随机矩阵A中非零元素
a := sprandn2(5, 5, 0.2);
return spnonzeros(a);
// 输出：一维数组，按顺序列出稀疏矩阵 a 中所有非零元素的值。
// 因 a 由 sprandn2 生成，非零元素个数与数值每次运行都不同。
```
## `ifsparse(s)`
判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数。
| 参数 | 类型 | 说明 |
| ---- | ------------- | ---------- |
| `s` | array of real | 待判断矩阵 |
返回：integer
### 示例
```tsl
// 判断矩阵S是否为稀疏矩阵
s := Array(3: 2, "B": 3);
return ifsparse(s); // 返回0
```
## `spdiags1(a)`
提取矩阵非零对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `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)`
提取矩阵指定对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------------------ |
| `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)`
根据指定列替换稀疏矩阵对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `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)`
根据指定列创建稀疏矩阵
| 参数 | 类型 | 说明 |
| ---- | ------- | -------------------------------- |
| `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);
```
## `compareDataOfDifferentDataProvider(t_src, t_dest, src_provider, dest_provider, key_arr, value_arr, code_field)`
比较两个数据源的差异
| 参数 | 类型 | 说明 |
| --------------- | ------ | ------------------------------------------------------ |
| `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
## `pivot(t, index, columns, vals)`
透视，数据透视表
| 参数 | 类型 | 说明 |
| --------- | --------------- | -------------------------------------------------------------------------------------------------------- |
| `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))
```
## `nonIntersectionPart(t1, t2, key_field)`
求差集(返回在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)
```
## `getSubTableByKey(t, key_field, return_fields)`
将字符串KeyField以分号分隔,在数组t中从列ReturnFields匹配被分割的值,若找到则返回该行信息，否则返回空数组。
| 参数 | 类型 | 说明 |
| --------------- | ------ | ------------------------ |
| `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');
// 返回:
```
## `expandTable(t, key_field)`
按指定字段展开表格，根据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))
```
Reference in New Issue View Git Blame Copy Permalink