playbook/skills/tsl-api-reference/references/codegen/dotnet/runtime/array.md

运行时 / 数组

数组 / 基础函数

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

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return istable(t1);
// 结果：1

noRecordTable()

返回一个空数组

返回：array,tablearray

示例

return noRecordTable();
// 结果：Array()

getSubTable(table, field_arr)

将一个表类型数组只保留指定的字段并返回

参数	类型	说明
table	array	二维数组
field_arr	array	列标名，一维数组

返回：array

示例

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

示例

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

示例

t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldExist(t1, 'b');
// 结果：1

fieldNames(t)

返回数据表所有字段名称

参数	类型	说明
t	array	数据表

返回：array

示例

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

示例

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

示例

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

示例

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

示例

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

示例

return rdo2 passwordGen(8, 5, 'ts', 3);
// 返回:

appendArray(arr, con)

数组新增元素，给数组arr添加一项con

参数	类型	说明
arr	array	一维数组
con	integer	整数或字符串，需增加的值

返回：array

示例

a := array(1, 2, 3);
appendArray(a, 4);
return a;
// 返回:

in1(v, x)

判断数值x是否在数组v中，返回布尔类型

参数	类型	说明
v	array	一维数组
x	real	实数

返回：bool

示例

a := array(1, 2, 3, 4);
return in1(a, 3);
// 结果：1

deleteColumnByField(t, fields)

删除指定列，可以一次性删除多列，删除的列字段之间使用；分割

参数	类型	说明
t	array	指定数组，数据表列名为字符串类型，程序执行完后会变更为删除指定列后的数组
fields	string	指定列，字符串

返回：array

示例

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

示例

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

示例

return seekPosInArray(4, array(1, 2, 3, 4, 5));
// 返回：3

outPutTableToCanBeUnderstood(t)

判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组。

参数	类型	说明
t	array	数组，数据表。

返回：string|array

示例

return outPutTableToCanBeUnderstood(array(1, 2, 3));
// 返回:

filterOneDimEx2(t, v1)

小于等于指定值的最后一条记录(一维数组)。

参数	类型	说明
t	array	一维数字数组
v1	real	实数，指定值

返回：real

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

// '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

示例

a := array(('a': 8, 'b': 7), ('a': 6, 'b': 9));
return getSubField(a, 'a'); // 从a表中取第’a列’
// 输出：
// 示例包含说明文字，未作为可执行片段运行。

mergeArray(v1, v2, ...)

多个数组进行合并

参数	类型	说明
v1	array
v2	array
...

返回：array

示例

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

示例

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

示例

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

示例

a := array('w', 'd', 'f', 'd', 'e');
return distinctStr(a); // 保留不相同的，相同的只保留一个
// 输出：
// 示例包含说明文字，未作为可执行片段运行。

sumValueByColumn(t, f_name)

指定列中所有实数的和

参数	类型	说明
t	array	数据表
f_name	string	指定字段

返回：real

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

// 生成数据表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

示例

// 生成数据表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

示例

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

示例

// 生成数据表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

示例

t := array('a', 'c', 'd');
return quickRecordExist(t, 'd');
// 结果：2

rotateTable(data)

旋转表

参数	类型	说明
data	array	数据表，二维数组

返回：array

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

x := array(9, 8, 10);
return argmax(x); // 2

argmin(x)

1、返回一维数组中最小值所在下标

参数	类型	说明
x	array,tablearray	一维数字数组

返回：integer

示例

x := array(3, 1, 9, 2);
return argmin(x); // 1

sortTableByFieldExt(t, sort_field)

将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并。

参数	类型	说明
t	array	数据表类型，数组
sort_field	string	字符串,排序字段

返回：any

示例

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

示例

// 对涨幅列进行排名，结果新增“涨幅(%)排名”列，并按排名升序重排
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

示例

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

示例

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

示例

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

示例

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

示例

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：

// 向一维数组指定位置插入一个字符串’aaa’
t := 43456->43460;
index := 2;
r_data := 'aaa';
return inserttablebyrno(t, index, r_data);
// 结果：array(43456,43457,"aaa",43458,43459,43460)

范例2：

// 向一维数组第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：

// 向二维数组第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：

// 向二维数组第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

示例

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

示例

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

示例

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：数字插入

v := array(1, 2, 3, 4, 5, 6);
return searchsorted(v, 3.5); // 返回：3

范例2：字符串插入

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：实数对比

a := 0->9;
return argconfirst(a, 3.5, 1); // 返回：4

范例2：数组对比

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。

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

示例：返回奇异值的位置及处理后的结果。

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

范例一：

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 生成的是随机正态样本，各区间的频数、频率(%)、累计频率(%)每次运行都不同。

范例二：

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：

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

// 多字段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

// 只更名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

示例

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

示例

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

示例

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：

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

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

示例

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：

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

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

// 从字符串数组中有放回随机抽取 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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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

示例

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:

load_dataset_iris(data);
return describe(data);

范例02:

return describe(randn(0, 1, 1000), array(0.05, 0.1)->0.95);

framecorrel(data)

数据表-相关系数矩阵

参数	类型	说明
data	table	Table,二维数据表，列名可为字符串,不支持一维数组

返回：array

示例

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

示例

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

示例

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

示例

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

示例

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

示例

// 给随机数组批量加后缀
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

示例

// 将矩阵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

示例

// 根据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

示例

// 创建m*m稀疏单位矩阵
a := speye(4);
return a;
// 输出：
// array(
// (1),
// (1:1),
// (2:1),
// (3:1))

sprand1(s)

创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 创建与矩阵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

示例

// 创建10*10稀疏均匀随机矩阵
a := sprand2(10, 10, 0.3);
return a;
// 输出：10*10 稀疏矩阵，约 30% 位置非零，非零元素为 (0,1) 均匀随机数。
// 非零位置与数值每次运行都不同。

sprandn1(s)

创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 创建与矩阵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

示例

// 创建10*10稀疏正态随机矩阵
a := sprandn2(10, 10, 0.2);
return a;
// 输出：10*10 稀疏矩阵，约 20% 位置非零，非零元素为标准正态随机数。
// 非零位置与数值每次运行都不同。

sprandsym1(s)

创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 创建与矩阵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

示例

// 创建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

示例

// 将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

示例

// 将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

示例

// 稀疏正态随机矩阵A中非零元素数目
a := sprandn2(5, 5, 0.2);
return spnnz(a); // 返回4（随机）

spnonzeros(s)

提取稀疏矩阵S中的非零元素

参数	类型	说明
s	array of real	稀疏矩阵

返回：array

示例

// 提取稀疏正态随机矩阵A中非零元素
a := sprandn2(5, 5, 0.2);
return spnonzeros(a);
// 输出：一维数组，按顺序列出稀疏矩阵 a 中所有非零元素的值。
// 因 a 由 sprandn2 生成，非零元素个数与数值每次运行都不同。

ifsparse(s)

判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数。

参数	类型	说明
s	array of real	待判断矩阵

返回：integer

示例

// 判断矩阵S是否为稀疏矩阵
s := Array(3: 2, "B": 3);
return ifsparse(s); // 返回0

spdiags1(a)

提取矩阵非零对角线

参数	类型	说明
a	array	Array,二维数组，原（稀疏）矩阵

返回：array

示例

// 提取矩阵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

示例

// 提取矩阵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

示例

// 将矩阵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

示例

// 根据对角矩阵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

示例

// 行标为日期、列标为名称，值为收盘价和涨幅的数据透视表
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

示例

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

示例

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

示例

// 按照分红送股列展开数据：分红送股列本身是子表，展开为多行
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))