126 KiB
126 KiB
基础函数 / 数组
arrDropDuplicate(data)
声明：function
数组去重（包含 NAN）；仅保留用于识别旧代码
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 数据表类型。数据表。 |
返回：array
示例
t := array(("A":1, "B":NAN), ("A":1, "B":2), ("A":1, "B":NAN), ("A":1, "B":2));
return arrDropDuplicate(t);
// 输出：array(("A":1,"B":NAN),("A":1,"B":2))
descartesJoin(v_1, v_2, ...)
声明：function
计算多个值或数组的笛卡尔积
| 参数 | 类型 | 说明 |
|---|---|---|
v_1 |
any | 第一个值或数组 |
v_2 |
any | 第二个值或数组 |
... |
any | 可选。更多值或数组 |
返回：array
示例
范例01：连接三个输入值
return descartesJoin(1->3, 21->22, 3);
// 输出：
// array(
// (1,21,3),
// (1,22,3),
// (2,21,3),
// (2,22,3),
// (3,21,3),
// (3,22,3))
framemerge(left, right, ons, how, suffixes, if_multi_field, keep_method)
声明：function
按指定字段连接两个数据表
| 参数 | 类型 | 说明 |
|---|---|---|
left |
table | 左表 |
right |
table | 右表 |
ons |
string|array | 连接字段或左右表连接字段数组 |
how |
string|integer | 可选。连接方式，默认 inner |
suffixes |
array | 可选。重名字段后缀，默认 array('_x', '_y') |
if_multi_field |
boolean | 可选。是否按多个共同字段连接，默认 false |
keep_method |
integer | 可选。重名字段保留方式，默认 0 |
返回：array
示例
范例01：按 id 执行内连接
left := `array('id': (1, 2), 'left_value': (10, 20));
right := `array('id': (2, 3), 'right_value': (30, 40));
return framemerge(
left, right, 'id', 'inner', array('_x', '_y'), false, 0);
// 输出：array(("id_x":2,"left_value":20,"id_y":2,"right_value":30))
frameupdate(left, right, ons, type)
声明：function
按键字段用右表补充或更新左表中的缺失值，并直接修改左表
| 参数 | 类型 | 说明 |
|---|---|---|
left |
table | 待更新的左表 |
right |
table | 提供更新值的右表 |
ons |
string|array | 可选。键字段，省略时按下标连接 |
type |
integer | 可选。缺失值类型位掩码，默认 15 |
返回：array
示例
范例01：用右表填充左表缺失值
left := `array('id': (1, 2), 'value': (nil, 20));
right := `array('id': (1, 2), 'value': (10, 30));
return frameupdate(left, right, 'id', 15);
// 输出：
// array(
// ("id":1,"value":10),
// ("id":2,"value":20))
getSubTableByField(t, fields)
声明：function
按字段名称提取数据表的指定列
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
fields |
string | 字段名称，多个名称用分号分隔 |
返回：array
示例
范例01：提取 name 和 price 两列
value := array(
("name": "A", "price": 1, "amount": 10),
("name": "B", "price": 2, "amount": 20));
return getSubTableByField(value, "name;price");
// 输出：
// array(
// ("name":"A","price":1),
// ("name":"B","price":2))
renameFieldByFormat(t, suffix, if_copy)
声明：function
按格式字符串批量修改数据表字段名
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 待处理数据表 |
suffix |
string | 格式字符串，%s 表示原字段名 |
if_copy |
boolean | 可选。是否在副本上修改，默认 true |
返回：array
示例
范例01：为全部字段添加后缀
value := array(("a": 1, "b": 2));
return renameFieldByFormat(value, "%s_x", true);
// 输出：array(("a_x":1,"b_x":2))
speye(m)
声明：function
创建指定阶数的稀疏单位矩阵
| 参数 | 类型 | 说明 |
|---|---|---|
m |
integer | 矩阵阶数 |
返回：array
示例
范例01：创建三阶稀疏单位矩阵
return speye(3);
// 输出：
// array(
// (1),
// (1:1),
// (2:1))
tableType(t)
声明：function
判断数组的数据表下标类型
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 待判断数组 |
不是数组时返回 -1，字符串下标数组返回 0，数字下标数组返回 1
返回：integer
示例
范例01：判断数字下标二维数组
return tableType(array((1, 2), (3, 4)));
// 输出：1
webFormatToRung(a, type, zero_eps)
声明：function
将数组中的 nan、nil、正负无穷和接近零的数值替换为短横线
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 待处理数组 |
type |
integer | 可选。替换类型位掩码，默认 15 |
zero_eps |
real | 可选。接近零的判断阈值，默认 epsi() |
返回：any
示例
范例01：替换 nil 和 nan
value := array(nil, nan, 1);
return webFormatToRung(value, 15, 1e-10);
// 输出：array("-","-",1)
abnormalData(y, flag, ystore)
声明：function
数组中出现奇异值的处理。其中y为数据表，Flag为处理方法，Ystore为选择中位数和3倍标准差法返回被处理数据的数据
| 参数 | 类型 | 说明 |
|---|---|---|
y |
array | 一维数字数组 |
flag |
string | 用户自定义，奇异值处理方法 |
ystore |
array | 数据表类型，存放修改的数据，包括修改的行、原数值、处理后的值 |
返回：any
示例
示例：返回奇异值的位置及处理后的结果。
t := array(1, 100, 101, 102, 103, 1000);
abnormalData(t, "median", r);
return r;
// 输出：
// 其中，0和5为修改的行，1和1000是对应的原值，93.7和109.3是修改后的值
appendArray(arr, con)
声明：function
数组新增元素，给数组arr添加一项con
| 参数 | 类型 | 说明 |
|---|---|---|
arr |
array | 一维数组 |
con |
integer | 整数或字符串，需增加的值 |
返回：array
示例
a := array(1, 2, 3);
appendArray(a, 4);
return a;
// 输出：
argconfirst(a, v, _type)
声明：function
第一次满足条件的位置, 原数组必须为有序表且元素应可比较
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 有序数组 |
v |
string|real|array | 对比值 |
_type |
integer | 对比条件 |
返回：integer
示例
范例1：实数对比
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
argmax(x)
声明：function
1、返回一维数组中最大值所在下标
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array,tablearray | 一维数字数组 |
返回：integer
示例
x := array(9, 8, 10);
return argmax(x);
// 输出：2
argmin(x)
声明：function
1、返回一维数组中最小值所在下标
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array,tablearray | 一维数字数组 |
返回：integer
示例
x := array(3, 1, 9, 2);
return argmin(x); // 输出：1
argsort(value, sortdir)
声明：function
返回可以用于排序的一维数组下标
| 参数 | 类型 | 说明 |
|---|---|---|
value |
array | 一维数字数组，数组 |
sortdir |
integer | 整数，排序方向（1:正序【默认】;0:逆序） |
返回：array
示例
value := array(4, 8, 2, 3, 9);
return argsort(value); // 输出：array(2,3,0,1,4)
arrayAddGap(t, key, v, m)
声明：function
数组添加分割线,只支持字符串下标
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组，待添加数组，直接在原数组更改 |
key |
string | 字符串，间隔名，默认无 |
v |
string | 字符串，间隔串，默认为 DupeString('-',m*2) |
m |
integer | 整型，间隔串的长度设置，默认 5 |
返回：array
示例
a := array('alpha(%)': 3);
arrayAddGap(a, '风险');
a['beta'] := 3;
return a; // 输出：array("alpha(%)":3,"-----风险-----":"----------","beta":3)
arrayextend(a, ind, v)
声明：function
数组-指定位置插入子集
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array of number | Array of number,一维数字数组 |
ind |
integer | Integer,插入的起始位置 |
v |
array of number | Array of number,插入的子数组 |
返回：array
示例
a := letters(1->6);
return arrayextend(a, 2, array('d', 'e'));
// 输出：array("A", "B", "d", "e", "C", "D", "E", "F")
arraygetdefault(r, k, v)
声明：function
带默认值的数组取值，取指定下标的值，若存在则返回，否则返回设定的默认值
| 参数 | 类型 | 说明 |
|---|---|---|
r |
array of string | Array of string, |
k |
string | String,下标 |
v |
string | String,默认值 |
返回：any
示例
r := array("a": 1, "b": 2);
return arraygetdefault(r, "x", 99); // 下标 x 不存在，返回默认值 99；若取 "a" 则返回 1
// 输出：99
arrayinsert(a, ind, v)
声明：function
数组-指定位置插入值
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array of number | Array of number,一维数字数组 |
ind |
integer | Integer,插入位置 |
v |
any | Any,元素值 |
返回：array
示例
a := letters(1->6);
return arrayinsert(a, 2, 3);
// 输出：array("A", "B", 3, "C", "D", "E", "F")
arraysetdefault(r, k, v)
声明：function
带默认值的数组赋值(字段未使用则赋值)
| 参数 | 类型 | 说明 |
|---|---|---|
r |
array of string | Array of string, |
k |
string | String,下标 |
v |
string | String,默认值 |
返回：bool
示例
r := array("a": 1, "b": 2);
arraysetdefault(r, "x", 99); // 下标 x 未使用，赋值 99 并返回 true；若对已存在的 "a" 调用则不改、返回 false
return r;
// 输出：array("a":1,"b":2,"x":99)
arraysetdefault2(r, k, v)
声明：function
带默认值的数组赋值(值为nil则赋值)
| 参数 | 类型 | 说明 |
|---|---|---|
r |
array of string | Array of string, |
k |
string | String,下标 |
v |
string | String,默认值 |
返回：bool
示例
r := array("a": 1, "b": nil);
arraysetdefault2(r, "b", 99); // b 的值为 nil，赋值 99 并返回 true；下标缺失时同样赋值
return r;
// 输出：array("a":1,"b":99)
aveDevByColumn(t, f_name)
声明：function
指定列与平均值的绝对偏差的平均值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名，字符串 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return aveDevByColumn(t2, 'c');
// 输出：12.5
averageByColumn(t, f_name)
声明：function
求指定列的平均值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名 |
返回：real
示例
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return averageByColumn(t1, 'b');
// 输出：6
averageValueByColumn(t, f_name, from_row, to_row)
声明：function
求在指定多行中指定列的平均值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名 |
from_row |
integer | 计算起始行索引号（从0开始） |
to_row |
integer | 计算结束行索引号（从0开始） |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return averageValueByColumn(t2, 'c', 1, 3);
// 输出：43
columnValue(t, fname)
声明：function
获取指定列的所有值(按列名)。该函数的功能与直接用读取子矩阵的方式一样，但是用子矩阵的方式更简单快速。功能相当于t[:,fname]
| 参数 | 类型 | 说明 |
|---|---|---|
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, '收盘');
// 输出：
columnValue2(t, column_name)
声明：function
获取多个指定列的所有记录
| 参数 | 类型 | 说明 |
|---|---|---|
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');
compareDataOfDifferentDataProvider(t_src, t_dest, src_provider, dest_provider, key_arr, value_arr, code_field)
声明：function
比较两个数据源的差异
| 参数 | 类型 | 说明 |
|---|---|---|
t_src |
array | Array 源数据 |
t_dest |
array | Array 目标数据 |
src_provider |
string | String 源数据提供商 |
dest_provider |
string | String 目标数据提供商 |
key_arr |
array | Array 要比较表的Key字段（也就是数据表中的 唯一性字段） |
value_arr |
array | Array 要比较的Value字段 |
code_field |
string | String 代码字段（任何数据，都必须有编码字段） |
返回：array
示例
src := array(("code": "A", "value": 1));
dest := array(("code": "A", "value": 1));
result := compareDataOfDifferentDataProvider(
src,
dest,
"source",
"target",
array("code"),
array("value"),
"code"
);
echo trim(toStn(result));
DataProcess_MF(arr, fwm)
声明：function
极值处理(多因子),对数据表以列为单位处理奇异值。其中arr为数据表，fwm为处理方法
| 参数 | 类型 | 说明 |
|---|---|---|
arr |
array | 数据表类型 |
fwm |
string | 用户自定义，处理方法 |
返回：any
示例
data := array(array(1, 100, 101, 102, 103, 1000), array(2, 200, 201, 202, 203, 2000));
echo trim(toStn(DataProcess_MF(data, "median")));
deleteColumnByField(t, fields)
声明：function
删除指定列，可以一次性删除多列，删除的列字段之间使用；分割
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 指定数组，数据表列名为字符串类型，程序执行完后会变更为删除指定列后的数组 |
fields |
string | 指定列，字符串 |
返回：array
示例
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return deleteColumnByField(t1, 'a;b');
deleteNilValueByField(t, fields)
声明：function
删除指定字段fields数据为NIL的记录
| 参数 | 类型 | 说明 |
|---|---|---|
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))
describe(data, percentiles)
声明：function
简单描述统计
| 参数 | 类型 | 说明 |
|---|---|---|
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);
devsqByColumn(t, f_name)
声明：function
指定列平均值偏差的平方和
| 参数 | 类型 | 说明 |
|---|---|---|
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
distinctStr(t)
声明：function
去掉序列中的重复元素
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 一维字符串/数字数组 |
返回：array
示例
a := array('w', 'd', 'f', 'd', 'e');
return distinctStr(a); // 保留不相同的，相同的只保留一个
dumies_decode(dumiesdata)
声明：function
虚拟变量矩阵解构，根据所给的虚拟变量矩阵返回分类变量结果
| 参数 | 类型 | 说明 |
|---|---|---|
dumiesdata |
array | 二维数字数组，虚拟变量矩阵 |
返回：array
示例
data := array(
("real_estate": 1, "metal": 0, "bank": 0),
("real_estate": 0, "metal": 1, "bank": 0),
("real_estate": 0, "metal": 0, "bank": 1)
);
echo trim(toStn(dumies_decode(data)));
elementWhere(con, x, y)
声明：function
根据布尔数组con,为True时从X中，为False时从Y中，取对应位置元素的值
| 参数 | 类型 | 说明 |
|---|---|---|
con |
array,tablearray | |
x |
array,tablearray | |
y |
array,tablearray |
返回：array,tablearray
示例
con := array(1, 0, 1, 1, 1, 0);
x := array(1, 2, 3, 4, 5, 6);
y := array(11, 12, 13, 14, 15, 16);
return elementWhere(con, x, y); // 输出：array(1,12,3,4,5,16)
expandTable(t, key_field)
声明：function
按指定字段展开表格，根据Keyfield展开指定列。展开的列值必须二维数据表，否则保留原值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组类型，数据 |
key_field |
string | 字符串类型，关键字，需展开的列名 |
返回：array
示例
// 按照分红送股列展开数据：分红送股列本身是子表，展开为多行
data := array(
("代码":"SH600000", "名称":"浦发银行", "分红送股":array(("年度":2019, "派息":6), ("年度":2020, "派息":8))),
("代码":"SZ000002", "名称":"万科A", "分红送股":array(("年度":2020, "派息":12))));
return expandTable(data, "分红送股");
// 输出：
// array(
// ("代码":"SH600000","名称":"浦发银行","分红送股":2019),
// ("分红送股":6),
// ("分红送股":2020),
// ("分红送股":8),
// ("代码":"SZ000002","名称":"万科A","分红送股":2020),
// ("分红送股":12))
factorize(value, ifsort, nan_fill_value, uniques)
声明：function
分类变量数值映射，将一个一维分类变量数组映射为给分类变量递增编号后的数值数组
| 参数 | 类型 | 说明 |
|---|---|---|
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);
Field_AddPrefix(t, prefix, ifcopy)
声明：function
数组下标批量加前缀
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组类型，数据 |
prefix |
string | 字符串类型，前缀 |
ifcopy |
bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
示例
data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddPrefix(data, "pre_", true)));
Field_AddSuffix(t, suffix, ifcopy)
声明：function
数组下标批量加后缀
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组类型，数据 |
suffix |
string | 字符串类型，后缀 |
ifcopy |
bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
示例
data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddSuffix(data, "_new", true)));
Field_ReSortCols(data, cols_showpriority)
声明：function
数组下标按指定顺序重排 ps：不检查字段是否存在
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 二维数字数组,数组，目前只支持二维 |
cols_showpriority |
array | 一维字符串数组,字段显示优先级 |
返回：array
示例
data := array(("code": "A", "value": 1, "date": 20250101));
priority := array("value": 100, "date": -1);
echo trim(toStn(Field_ReSortCols(data, priority)));
fieldCount(t)
声明：function
数据表字段个数。如果t不是一个数据表，则返回0
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
返回：integer
示例
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldCount(t1);
// 输出：2
fieldCountOfStrSubscript(t)
声明：function
字符串下标数组的字段个数
| 参数 | 类型 | 说明 |
|---|---|---|
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
fieldExist(t, f_name)
声明：function
指定字段是否存在。如果存在，则返回索引号；(索引号从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
fieldName(t, field_index)
声明：function
返回数据表指定列索引号（索引号从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
fieldNames(t)
声明：function
返回数据表所有字段名称
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
返回：array
示例
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));return fieldNames(t1);
fieldNamesOfStrSubscript(t)
声明：function
字符串下标数组的字段名称
| 参数 | 类型 | 说明 |
|---|---|---|
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);
// 输出：
filterIntersectionPart(t1, t2, f_name, method)
声明：function
求两个数组在指定列名上的差集、交集、并集
| 参数 | 类型 | 说明 |
|---|---|---|
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)
声明：function
求两个数组的差集、交集、并集。只适用一维数组
| 参数 | 类型 | 说明 |
|---|---|---|
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)。
filterOneDimEx(t, method, v1, v2)
声明：function
范围取值（一维数组）从一个一维数组中按照取值范围返回对应的记录
| 参数 | 类型 | 说明 |
|---|---|---|
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);
filterOneDimEx2(t, v1)
声明：function
小于等于指定值的最后一条记录(一维数组)
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 一维数字数组 |
v1 |
real | 实数，指定值 |
返回：real
示例
s := array(1, 2, 3, 4, 5, 6);
return filterOneDimEx2(s, 4);
// 输出：4
filterTable(t, v)
声明：function
从指标表中取以下列的值为v的数据
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组类型，数据 |
v |
integer | 报告期类型，报告期 |
返回：array
示例
// 'SZ002664'在20211231时的分红送股数据
setSysParam(pn_stock(), 'SZ002664');
return filterTable(infoArray(18), 20211231);
filterTableEx(t, fname, method, v1, v2)
声明：function
范围取值，从一个表中按照某个字段的取值范围返回对应的记录
| 参数 | 类型 | 说明 |
|---|---|---|
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
footerAverage(t, from_col, tocol, average_col_field)
声明：function
调用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)
声明：function
调用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, '');
// 输出：
footerValue(t, from_col, tocol, average_col_field, _type)
声明：function
数组t从Fromcol列到ToCol列对每列求算术平均或者累计求和
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型，数据表 |
from_col |
integer | :整数，起始序号 |
tocol |
integer | 整数，截止序号 |
average_col_field |
string | 字符串，列名 |
_type |
any | 用户自定义 |
返回：array
示例
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerValue(s, 1, 3, '', 1);
// 输出：
Frame_addprefix(t, prefix, ifcopy)
声明：function
数据表-数组下标批量加前缀 二维数组，对列名加前缀 一维数组，对行下标加前缀
| 参数 | 类型 | 说明 |
|---|---|---|
t |
any | Table,源数组 |
prefix |
string | String,前缀 |
ifcopy |
bool | Bool,是否在拷贝后的数组改列名,默认True |
返回：array
示例
data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addprefix(data, "pre_", true)));
Frame_addsuffix(t, suffix, ifcopy)
声明：function
数据表-数组下标批量加后缀 二维数组，对列名加后缀 一维数组，对行下标加后缀
| 参数 | 类型 | 说明 |
|---|---|---|
t |
any | Table,源数组 |
suffix |
string | String,后缀 |
ifcopy |
bool | Bool,是否在拷贝后的数组改列名，默认True |
返回：array
示例
data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addsuffix(data, "_new", true)));
frameconcat(arrdic, _type)
声明：function
数据表-拼接
| 参数 | 类型 | 说明 |
|---|---|---|
arrdic |
array | Array of number,数组的数组,需要拼接的数组集合 |
_type |
Usrdefine | Usrdefine,数组拼接方式，默认为0行并=0；列并=1；非完全矩阵列并=2 |
返回：array
示例
a := ones(3, 3);
b := ones(2, 3);
frameconcat(array(a, b));
framecorrel(data)
声明：function
数据表-相关系数矩阵
| 参数 | 类型 | 说明 |
|---|---|---|
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)
声明：function
数据表-协方差
| 参数 | 类型 | 说明 |
|---|---|---|
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);
framecut(a, bins, option, o_lables)
声明：function
从小到大分段分组，最小的为第0组
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 数据表或一维数字数组，数据表时，表示对每列分别操作 |
bins |
array | 一维数字数组，分段节点，例如array(0,1)将数组a分为[-inf,0)[0,1)[1,inf)三段， |
option |
integer | 整型，区间开/闭，默认为0 |
o_lables |
integer | 数组，输出分组区间说明 |
返回：array
示例
范例01：插入一个字符串
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)
Framedrop_duplicates(data, subset, keep, rowname)
声明：function
数据表-去重
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | Table,二维数据表,源数据 |
subset |
string | String,去重字段 |
keep |
string | String,去重保留方法，""f"":保留首个，""l"":保留最后 |
rowname |
string | String,保留原索引重置字段名 |
返回：array
示例
data := array(
("code": "A", "value": 1),
("code": "A", "value": 2),
("code": "B", "value": 3)
);
echo trim(toStn(Framedrop_duplicates(data, "code", "f", "source_index")));
Framedrop_na(data, how, subset)
声明：function
数据表-去掉含Nan的行
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | Table,二维数据表,源数据 |
how |
string | String,去na行方法，默认/1/""any"":任意，2/""all"":所有 |
subset |
string | String,去重字段 |
返回：array
示例
data := array((nan, 8), (1, 3));
echo trim(toStn(Framedrop_na(data, "any", array(0))));
frameGetSubByReg(data, reg)
声明：function
通过正则表达式匹配获取数据框子集
| 参数 | 类型 | 说明 |
|---|---|---|
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))
framehhi(data)
声明：function
数据表-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
frameIndex_filter(rawkeys, filter_cond, filter_type, dz_valuetokey)
声明：function
数组筛选器，用于下标数组行名或列名的筛选器
| 参数 | 类型 | 说明 |
|---|---|---|
rawkeys |
array | 一维字符串数组,下标数组(0开始的自增下标) |
filter_cond |
string | 字符串,筛选条件 |
filter_type |
any | 用户自定义,筛选类型 |
dz_valuetokey |
any | 整数,Out:类型1时，输出ivalue对照用 |
返回：array
示例
columns := array("name", "period", "factor", "IC@mean", "IC@ratio");
echo trim(toStn(frameIndex_filter(columns, array("period", "factor"), 1)));
frameIndex_getilocDZ(raw_data_cols)
声明：function
用于方便获取 下标值 与 字段位置 下标数组对照（下标值->下标位置）
| 参数 | 类型 | 说明 |
|---|---|---|
raw_data_cols |
array | 一维字符串数组,下标数组(从0开始自增数组) |
返回：array
示例
echo trim(toStn(frameIndex_getilocDZ(array("growth", "value", "momentum"))));
frameinsert(data, loc, fname, v)
声明：function
数据表-指定位置插入列
| 参数 | 类型 | 说明 |
|---|---|---|
data |
table | Table,二维数据表,源数据 |
loc |
integer | Integer,插入位置 |
fname |
string | String,插入索引命名 |
v |
integer | Integer,插入值 |
返回：array
示例
data := array(
("SepalLength":4.6, "SepalWidth":3.1),
("SepalLength":5.0, "SepalWidth":3.6),
("SepalLength":5.4, "SepalWidth":3.9));
return frameinsert(data, 1, '新列', 0);
// 输出：
// array(
// ("SepalLength":4.6,"新列":0,"SepalWidth":3.1),
// ("SepalLength":5.0,"新列":0,"SepalWidth":3.6),
// ("SepalLength":5.4,"新列":0,"SepalWidth":3.9))
Framelag_zf(t, period, fillzero)
声明：function
数据表-推移涨幅(%) 涨幅(%)算法： period>0: 前n期涨幅 r[i] := (t(i)/t(i-period)-1)*100; period<0: 到未来n期涨幅 r[i] := (t(i-period)/t(i)-1)*100; 注意period>0时，与framePct_change的结果一致
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | Array of number,数据表，支持一维和二维 |
period |
any | Integer,移动期数，默认1 |
fillzero |
bool | Bool,下标越界是，是否返回0.False返回inf |
返回：array
示例
echo trim(toStn(Framelag_zf(array(10, 5, 8, 2), 1, false)));
frameMelt(t, id_names, value_names, variable_sname, value_sname)
声明：function
二维表——>立体表
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 二维字符串数组，数据表 |
id_names |
array | 一维字符串数组，键字段 |
value_names |
array | 一维字符串数组，值字段。为nil或者空时，表每行除开键字段外都是值字段 |
variable_sname |
string | 字符串，变量展示名 |
value_sname |
string | 字符串，值展示名 |
返回：array
示例
t := array(
('截止日': 20210101, 'SH000300': 1, 'SH000301': 3),
('截止日': 20210102, 'SH000300': 9, 'SH000301': 2),
);
id_names := array('截止日');
return frameMelt(t, '截止日', nil, '代码', '得分');
Framepct_change(t, period, fillzero)
声明：function
数据表-到当期的变动百分比(%) 变动百分比(%)算法 r[i] := (t(i)/t(i-period)-1)*100
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | Array of number,数据表，支持一维和二维 |
period |
any | Integer,变动期数，默认1 |
fillzero |
bool | Bool,下标越界是，是否返回0. False返回inf |
返回：array
示例
echo trim(toStn(Framepct_change(array(10, 5, 8, 2), 1, false)));
framePivot_table(t, index, columns, vals, aggfunc, aggfuncnames)
声明：function
分组、透视、汇总，类似可见Pivot_table
| 参数 | 类型 | 说明 |
|---|---|---|
t |
any | 数据表类型,数据表 |
index |
string | 字符串,行分类字段，字段值含有nill等不可设为索引 |
columns |
array | 一维字符串数组,列分类字段，字段值含有nill等不可设为索引 |
vals |
array | 一维字符串数组,值字段，未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 |
aggfunc |
string | 字符串,值汇总函数,支持如下:；a、所有 TS_SQL 聚合函数:e.g:"avg"(avgof),"sum"(sumof)；b、内置函数:；"_details": 分组详情；"_first": 第一个；"_last": 最后一个；c、自定义函数中使用关键字thisgroup 得到当前分组数据。 |
aggfuncnames |
array | 一维字符串数组,自定义汇总函数名称对照表 |
返回：array
示例
data := array(
("group": "A", "date": "2025-01-01", "value": 1),
("group": "A", "date": "2025-01-02", "value": 2),
("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(framePivot_table(
data,
"group",
array("date"),
array("value"),
"sum",
nil
)));
frameqcut(data, q)
声明：function
数据表-按频率分组(等频分组)
| 参数 | 类型 | 说明 |
|---|---|---|
data |
table | Table,数据表或一维数字数组，数据表时，表示对 |
q |
integer | Integer,分组数，等分q组，正整数，默认q=5 |
返回：array
示例
data := array(1, 2, 3, 4, 5, 6, 7, 8, 9);
return frameqcut(data, 3); // 按大小等频分为 3 组，返回各元素所属组号(0,1,2)
// 输出：array(0,0,0,1,1,1,2,2,2)
framevaluecounts(data, countfieldname, iforder)
声明：function
数据表-计数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
table | Table,可以为二维数据表或者为一维数组 |
countfieldname |
string | String,计数字段名，默认为""个数"" |
iforder |
bool | Bool,是否排序，默认为真 |
返回：array
示例
data := array("a", "b", "a", "c", "a", "b");
return framevaluecounts(data, "个数", true); // 统计各值出现次数，按次数降序
// 输出：
// array(
// ("值":"a","个数":3),
// ("值":"b","个数":2),
// ("值":"c","个数":1))
geoMeanByColumn(t, f_name)
声明：function
指定列的几何平均值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名 |
返回：real
示例
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return geoMeanByColumn(t1, 'b');
// 输出：4.47
get_dummies(a, uniques)
声明：function
1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、如果a中含Nan值，排到uniques的末尾
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 一维数组，指定的分类变量 |
uniques |
array | 一维数组，中间结果:输出各列对应的分类变量 |
返回：array
示例
data := array("A", "B", "C", "A");
encoded := get_dummies(data, categories);
echo trim(toStn(array("categories": categories, "encoded": encoded)));
get_dummies2(a)
声明：function
1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、a中的元素必须都可以做为数组下标，否则请使用get_dummies
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 一维数组，指定的分类变量 |
返回：array
示例
echo trim(toStn(get_dummies2(array("A", "A", "B", "C"))));
getBottomN(t, n)
声明：function
取数组后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);
getDistinctValue(t, f_name)
声明：function
获取指定列唯一值，返回值为一维数组
| 参数 | 类型 | 说明 |
|---|---|---|
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');
getMiddleN(t, from_no, to_no)
声明：function
取数组指定行区间记录，一般先用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);
getSubField(t, field)
声明：function
获取取表中某一字段的全部列值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 二维数组 |
field |
string | 列标名，字符串/整数 |
返回：array
示例
a := array(('a': 8, 'b': 7), ('a': 6, 'b': 9));
return getSubField(a, 'a'); // 从 a 表中取第 'a' 列
getSubTable(table, field_arr)
声明：function
将一个表类型数组只保留指定的字段并返回
| 参数 | 类型 | 说明 |
|---|---|---|
table |
array | 二维数组 |
field_arr |
array | 列标名，一维数组 |
返回：array
示例
a := array((1, 2, 4), (11, 12, 14));
b := array(0, 2);
return getSubTable(a, b);
getSubTableByKey(t, key_field, return_fields)
声明：function
将字符串KeyField以分号分隔,在数组t中从列ReturnFields匹配被分割的值,若找到则返回该行信息，否则返回空数组
| 参数 | 类型 | 说明 |
|---|---|---|
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');
// 输出：
getSubTableFreeParam()
声明：function
取子表，系统第二个到最个一个参数为字段序列，取第一个参数中字段与字段序列匹配的列数据
返回：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'。
// 输出：
getTopN(t, n)
声明：function
取数组前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);
getValuesByFieldValue(t, f_name, field_value)
声明：function
返回指定字段值等于指定值的所有记录
| 参数 | 类型 | 说明 |
|---|---|---|
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 的所有记录
groupByFieldValue(t, group_field, lowvalue, high_value, sep_value)
声明：function
按字段大小进行汇总。小于最小值Lowvalue为一组，从最小值Lowvalue到最大值HighValue中间每步长SepValue为一组，大于最大值High为一组
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型 |
group_field |
string | 字符串，列名 |
lowvalue |
real | 实数，最小数值 |
high_value |
real | 实数，最大数值 |
sep_value |
real | 实数，统计间距 |
返回：any
示例
data := select * from tradetable datekey 20180903t to 20180904T of 'sz000001' end;
return groupByFieldValue(data, 'close', 1, 20, 0.1);
// 输出：
groupDemeanIt(t, g_name, v_name)
声明：function
1、分组去均值，对数据表t按[GName]分组后，对每组的[VName]去均值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
dbdata | 数据表，待分组去均值数据 |
g_name |
string | 字符串，t的分组字段名 |
v_name |
string | 字符串，去均值字段名 |
返回：array
示例
范例1：
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))
groupPercentrankIt(t, g_name, v_name)
声明：function
计算分组百分位，对数据表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)
声明：function
计算分组排名，对数据表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)
声明：function
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]根据给定函数进行分组转换操作
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组，待计算的数组 |
g_name |
string | 字符串，分组字段名 |
v_name |
string | 字符串或数组，转换字段名 |
fp |
string | 字符串（函数名）或函数指针，转换函数必须两个参数，分别表示当前的聚合字段与排名字段，以分组排名为例: |
返回：array
示例
范例01：使用自定义函数对分组数据进行转换
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
fp := function(v, g)
begin
return rankof([v], [v]);
end;
return groupTransformByFunc(t, 'G', 'V1', fp);
// 输出：array(3,3,2,2,1,1)
groupZscoreIt(t, g_name, v_name)
声明：function
1.计算分组标准化，对数据表t按[GName]分组后，对每组的[Vname_]进行标准化(原值-分组平均)/分组标准差
| 参数 | 类型 | 说明 |
|---|---|---|
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)
harMeanByColumn(t, f_name)
声明：function
指定列的调和平均值
| 参数 | 类型 | 说明 |
|---|---|---|
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
histogram(t, bins, format)
声明：function
统计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@频数 …… 等列。区间划分固定，但各频数因随机样本每次运行都不同。
ifsparse(s)
声明：function
判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数
| 参数 | 类型 | 说明 |
|---|---|---|
s |
array of real | 待判断矩阵 |
返回：integer
示例
// 判断矩阵S是否为稀疏矩阵
s := Array(3: 2, "B": 3);
return ifsparse(s); // 返回0
in1(v, x)
声明：function
判断数值x是否在数组v中，返回布尔类型
| 参数 | 类型 | 说明 |
|---|---|---|
v |
array | 一维数组 |
x |
real | 实数 |
返回：bool
示例
a := array(1, 2, 3, 4);
return in1(a, 3);
// 输出：1
inserttablebyrno(t, index, rdata)
声明：function
向表格指定位置插入行，天软表格行下标从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)
范例02：插入多行数据
// 向一维数组第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"))
intersectionPart(v, w)
声明：function
求交集
| 参数 | 类型 | 说明 |
|---|---|---|
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);
inverseTable(t)
声明：function
将数组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);
// 输出：
istable(t)
声明：function
判断是否为数组。如果t为数据表，返回True；否则，返回False
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
返回：bool
示例
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return istable(t1);
// 输出：1
kurtByColumn(t, f_name)
声明：function
指定列的峰度
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return kurtByColumn(t2, 'c');
// 输出：0.34
maxValueByColumn(t, f_name)
声明：function
求指定列中的最大值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return maxValueByColumn(t2, 'c');
// 输出：53
medianByColumn(t, f_name)
声明：function
指定列的中位数
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名，字符串 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return medianByColumn(t2, 'c');
// 输出：38
mergeArray(v1, v2, ...)
声明：function
多个数组进行合并
| 参数 | 类型 | 说明 |
|---|---|---|
v1 |
array | |
v2 |
array | |
... |
返回：array
示例
t1 := array(('b': 12, 'a': 1, 'c': 13, 'd': 'd'));
t2 := array(('a': 2, 'b': 22, 'c': 23, 'e': 'ee'));
t3 := array(('a': 2, 'b': 22, 'd': 23, 'e': 'ee'));
return mergeArray(t1, t2, t3); // 将数组t1,t2,t3合并
minValueByColumn(t, f_name)
声明：function
求指定中的最小值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return minValueByColumn(t2, 'c');
// 输出：13
nonIntersectionPart(t1, t2, key_field)
声明：function
求差集(返回在t1中存在，而在t2中不存在的记录)
| 参数 | 类型 | 说明 |
|---|---|---|
t1 |
array | 数据表 |
t2 |
array | 数据表 |
key_field |
string | 指定某一字段 |
返回：array
示例
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
t2 := array(('a': 1, 'b': 1), ('a': 7, 'b': 8), ('a': 5, 'b': 5));
return nonIntersectionPart(t1, t2, 'b');
// 输出：
// array(3,4)
noRecordTable()
声明：function
返回一个空数组
返回：array,tablearray
示例
return noRecordTable();
// 输出：Array()
normalTabletoStrSubscript(t, key_field)
声明：function
索引下标数组-->字符串下标数组。将keyfield列的值变为行标
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型 |
key_field |
string | 字符串，列名 |
返回：any
示例
s := nDay(10, 'time', dateToStr(sp_time()), 'close', close());
return normalTabletoStrSubscript(s, 'time');
// 把 time列的数据变为行标
outPutTableToCanBeUnderstood(t)
声明：function
判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数组，数据表。 |
返回：string|array
示例
return outPutTableToCanBeUnderstood(array(1, 2, 3));
// 输出：
passwordGen(len, n, head, start)
声明：function
密码生成器
| 参数 | 类型 | 说明 |
|---|---|---|
len |
integer | 整数，密码长度 |
n |
integer | 整数，生成的密码组合数 |
head |
string | 字符串，用户名的前缀 |
start |
integer | 整数，用户名的后缀序列数字的起始数字 |
返回：array
示例
范例01：生成五组密码
return passwordGen(8, 5, 'ts', 3);
此示例需在提供 passwordGen 的 Windows/.NET 运行环境中执行。本地 .tsl 脚本不使用 rdo2 包装调用。
percentValueByField(t, key_field, quart)
声明：function
数据集在指定百分位数上对应的数值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
key_field |
string | 指定列名，字符串 |
quart |
real | 指定分位数，实数 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return percentValueByField(t2, 'c', 0.1);
// 输出：19
pivot(t, index, columns, vals)
声明：function
透视，数据透视表
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 二维数组，待透视表，t[:,array(index,columns)] 不能包含重复的行，即index，columns 必须可以作为t的唯一主键 |
index |
string | array | 字符串或一维字符串数组，行分类字段，t的列名，多个字段可以用数组，为nil表示取t的行下标 |
columns |
string | array | 字符串或一维字符串数组，列分类字段，t的列名；结果列名形如 值字段@列分类值 |
vals |
string | array | 字符串或一维字符串数组，值字段，t的列名，多个字段可以用数组 |
返回：array
示例
// 行标为日期、列标为名称，值为收盘价和涨幅的数据透视表
t := array(
("日期":"2021-05-17", "名称":"平安银行", "收盘价":22.5, "涨幅":1.2),
("日期":"2021-05-17", "名称":"万科A", "收盘价":30.1, "涨幅":-0.8),
("日期":"2021-05-18", "名称":"平安银行", "收盘价":22.9, "涨幅":1.8),
("日期":"2021-05-18", "名称":"万科A", "收盘价":29.7, "涨幅":-1.3));
return pivot(t, "日期", "名称", array("收盘价", "涨幅"));
// 输出：
// array("2021-05-17":
// ("收盘价@万科A":30.1,"收盘价@平安银行":22.5,"涨幅@万科A":-0.8,"涨幅@平安银行":1.2),"2021-05-18":
// ("收盘价@万科A":29.7,"收盘价@平安银行":22.9,"涨幅@万科A":-1.3,"涨幅@平安银行":1.8))
Pivot_table(t, index, columns, vals, aggfunc, aggfuncnames)
声明：function
分组、透视、汇总 1、vals 未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 2、aggfunc 不同含义及设定方法： a、所有字段，统一函数 aggfunc := "avg" 注：代表对vals中所有字段进行计算 b、所有字段，多个函数 aggfunc := array("avg","max"); c、指定字段，指定函数 aggfunc := array("fielda":"avg","filedb":("avg","max")); 注：指定字段时，必须是vals的子集，否则报错。 3、支持匿名函数、与函数指针，其中: a、匿名函数默认命名为"匿名" b、函数指针通过functioninfo得到函数名称 4、aggfunc中支持 a、所有 TS_SQL 聚合函数：e.g:"avg"(avgof),"sum"(sumof) b、内置函数： "_details": 分组详情 "_first": 第一个 "_last": 最后一个 c、自定义函数中使用关键字thisgroup 得到当前分组数据。 5、index/columns中字段值含有nill等不可设为索引。 6、aggfuncnames：给aggfunc定义名称
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
index |
string|array | 行分类字段 |
columns |
string|array | 列分类字段 |
vals |
string|array | 值字段 |
aggfunc |
string|array|function | 汇总函数 |
aggfuncnames |
array | 自定义汇总函数名称对照表 |
返回：array
示例
data := array(
("group": "A", "date": "2025-01-01", "value": 1),
("group": "A", "date": "2025-01-02", "value": 2),
("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(Pivot_table(
data,
"group",
"date",
"value",
"sum",
nil
)));
QKsplit_Resampling(begt, endt, cy, if_name)
声明：function
区间自然日按指定周期重采样分割
| 参数 | 类型 | 说明 |
|---|---|---|
begt |
datetime | 日期时间，开始日 |
endt |
datetime | 日期时间，截止日 |
cy |
string | 字符串，采样周期，默认为cy_Day()，可以取日线、周线、月线、季线、半年线、年线 |
if_name |
string | object |
返回：array
示例
echo trim(toStn(QKsplit_Resampling(20100101T, 20110101T, cy_year(), "")));
QKsplit_ToDate(endt, _type)
声明：function
当前周期分割区间
| 参数 | 类型 | 说明 |
|---|---|---|
endt |
datetime | 日期时间，截止日 |
_type |
any | 整型，为以下数值的组合(以下数值的_XOR或者相加)，默认值为31(1+2+4+8+16) |
返回：array
示例
echo trim(toStn(QKsplit_ToDate(20220704T, 31)));
QKsplit_Trailing(begt, endt, inc_weeks, inc_months, inc_years, other_type)
声明：function
时间区间尾随分割
| 参数 | 类型 | 说明 |
|---|---|---|
begt |
datetime | 日期时间，开始日 |
endt |
datetime | 日期时间，截止日 |
inc_weeks |
any | 数字/数组，周推移，取值如下 |
inc_months |
any | 数字/数组，月推移，同inc_weeks |
inc_years |
any | 数字/数组，年推移，同inc_weeks |
other_type |
any | 整型，为以下数值的组合(以下数值的_XOR或者相加)，默认2 |
返回：array
示例
echo trim(toStn(QKsplit_Trailing(20100101T, 20110101T, nil, nil, nil, 2)));
quickIntersectionPart(v, w)
声明：function
快速求交集
| 参数 | 类型 | 说明 |
|---|---|---|
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);
quickRecordExist(v, x)
声明：function
记录是否存在(原数组若为纯字符串数组则必须为有序列)，返回记录所在行的序号，序号是从0开始原数组必须为有序表
| 参数 | 类型 | 说明 |
|---|---|---|
v |
array | 一维数组 |
x |
string | 字符串/数字 |
返回：integer
示例
t := array('a', 'c', 'd');
return quickRecordExist(t, 'd');
// 输出：2
randomchoice(avalues, size, replace)
声明：function
随机抽样
| 参数 | 类型 | 说明 |
|---|---|---|
avalues |
array of string | Array of string,一维字符串数组，或正整数 |
size |
integer | Integer, |
replace |
bool | Bool,是否可放回,默认为真可放回 |
返回：any
示例
// 从字符串数组中有放回随机抽取 3 个
return randomchoice(array("A", "B", "C", "D", "E"), 3, true);
// 输出：长度为 3 的随机子集，如 array("B","A","C")；因随机抽样每次运行结果不同。
// 若 avalues 传正整数 n，则从 0..n-1 中抽样，返回浮点下标数组。
rankIt(t, f_n, sort_order)
声明：function
按指定字段的值排名；SortOrder：0 降序排名；SortOrder：1升序排名
| 参数 | 类型 | 说明 |
|---|---|---|
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)
声明：function
按指定字段的值排名，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))
rankValue(t, fields)
声明：function
按照指定字段求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))
recordExist(t, v)
声明：function
数值是否在数组中存在（一维数组），如果存在，则返回索引号；(索引号从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)
声明：function
记录数据表（二维数组）中是否存在列名为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)
声明：function
记录指定值是否存在一维数组中，如果存在，返回1，不存在，返回0
| 参数 | 类型 | 说明 |
|---|---|---|
v |
string | 指定数组，一维数组 |
x |
integer | 指定值，与v单元值类型一致 |
返回：bool
示例
t := array(1, 2, 12, 3, 14);
return recordExist3(t, 3);
// 输出：1
renameField(t, old_field, new_field)
声明：function
修改指定字段的名称
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 指定数组，数据表 |
old_field |
string | 原来指定列名，字符串 |
new_field |
string | 新列名，字符串 |
返回：bool
示例
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return renameField(t1, 'a', 'aaa'); // 将 t1 中的字段 'a' 改为 'aaa'
// 输出：1
reverse(arr)
声明：function
数组倒置反向
| 参数 | 类型 | 说明 |
|---|---|---|
arr |
array | 数组 |
返回：array
示例
arr := array(
("date":"2021-05-26", "close":1),
("date":"2021-05-27", "close":2),
("date":"2021-05-28", "close":3),
("date":"2021-05-31", "close":4),
("date":"2021-06-01", "close":5));
return reverse(arr);
// 输出：
// array(
// ("date":"2021-06-01","close":5),
// ("date":"2021-05-31","close":4),
// ("date":"2021-05-28","close":3),
// ("date":"2021-05-27","close":2),
// ("date":"2021-05-26","close":1))
rotateTable(data)
声明：function
旋转表
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 数据表，二维数组 |
返回：array
示例
t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return rotateTable(t);
rpsIt(t, f_n, sort_order)
声明：function
按指定字段的值排名，获得其排名的百分位，排序百分位放在列 FN+"_RPS"中
| 参数 | 类型 | 说明 |
|---|---|---|
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))
rpsValue(t, column_name)
声明：function
按照指定字段求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))
searchsorted(v, x)
声明：function
有序列表插入指定值的位置，原数组必须为有序表且元素应可比较
| 参数 | 类型 | 说明 |
|---|---|---|
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
seekPosInArray(r, arr)
声明：function
数字定位，采用二分法寻找数字R在一位正序数字数组arr中的下标
| 参数 | 类型 | 说明 |
|---|---|---|
r |
real | 实数 |
arr |
array | 一维数字数组 |
返回：integer
示例
return seekPosInArray(4, array(1, 2, 3, 4, 5));
// 输出：3
seperateTable(t, sep_field, sep_count)
声明：function
把表格t分割为SepCount个表格
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型，原始数组 |
sep_field |
string | 字符串，排序字段 |
sep_count |
integer | 整数，分割数 |
返回：array
示例
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return seperateTable(t, 'a', 2);
// 输出：
// array(
// (
// ("a":4,"b":5,"c":6,"d":7,"e":8,"f":10),
// ("a":3,"b":4,"c":5,"d":6,"e":7,"f":9)),
// (
// ("a":2,"b":3,"c":4,"d":5,"e":6,"f":8),
// ("a":1,"b":2,"c":3,"d":4,"e":5,"f":7)))
setRowDefaultValue(t, n, value)
声明：function
将数组t的第N行由所有值变更为Value
| 参数 | 类型 | 说明 |
|---|---|---|
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;
// 输出：
show2DTable(t, key_field, obsolete_fields, ntype)
声明：function
特殊函数，平台功能性函数，一般用户不使用。二位表格显示格式转换，其中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);
// 输出：
show3DTable(t, key_field, obsolete_fields, ntype)
声明：function
特殊函数，平台功能性函数，一般用户不使用。用于三维表格显示格式转换，其中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);
// 输出：
showTableByField(t, field_arr)
声明：function
显示数据表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)
声明：function
数据表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);
// 输出：
ShowTableByUnit(t, field_arr)
声明：function
显示t部分字段(带显示单位变换)。其中FieldArr为二维数组，FieldArr的第0列为显示的字段名称，第1列为显示的字段对应的数据列名称，第2列为显示的字段的数据类型，第3列为显示的字段的单位(只对Real类型有意义)
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型，要显示的数据 |
field_arr |
array | 二位字符串数组，要显示的字段 |
返回：Array，数组。
示例
data := array("a": (1, 2), "b": (3, 4));
fields := array(("field_a", "a", "", ""));
echo trim(toStn(ShowTableByUnit(data, fields)));
simpledescribe(data)
声明：function
简单描述统计
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of number | 一维数字数组，或 二维矩阵，二维矩阵时，对每列进行操作 |
返回：array
示例
data := array(
("H": 10, "W": 2, "L": 4),
("H": 20, "W": 4, "L": 8),
("H": 30, "W": 6, "L": 12));
return simpledescribe(data);
// 输出：
// array("个数":
// ("H":3,"W":3,"L":3),"最小值":
// ("H":10.0,"W":2.0,"L":4.0),"25%":
// ("H":15.0,"W":3.0,"L":6.0),"50%":
// ("H":20.0,"W":4.0,"L":8.0),"75%":
// ("H":25.0,"W":5.0,"L":10.0),"最大值":
// ("H":30.0,"W":6.0,"L":12.0),"平均值":
// ("H":20.0,"W":4.0,"L":8.0),"标准差":
// ("H":10.0,"W":2.0,"L":4.0))
skewByColumn(t, f_name)
声明：function
指定列的偏度
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名，字符串 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return skewByColumn(t2, 'c');
// 输出：-0.75
sortTableByFieldExt(t, sort_field)
声明：function
将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并
| 参数 | 类型 | 说明 |
|---|---|---|
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');
// 输出：
sparse1(s, a, m, n)
声明：function
挤出任何非零元素，将满矩阵转化为稀疏格式，与Sparsefull函数对应
| 参数 | 类型 | 说明 |
|---|---|---|
s |
array of real | 待转化的m*n满矩阵 |
a |
array of real | 变参返回矩阵S的稀疏格式，二维数组 |
m |
integer | 变参返回矩阵S的行数，整数 |
n |
integer | 变参返回矩阵S的列数，整数 |
返回：array
示例
// 将矩阵S由满矩阵格式转化为稀疏格式
s := array((0, 0, 4, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 0, 0, 0),
(3, 0, 0, 0, 0),
(0, 0, 0, 0, 5));
return sparse1(s);
// 输出：
// array(0:
// (2:4),1:
// (1:1),3:
// (3),4:
// (4:5))
sparse2(i, j, v, m, n)
声明：function
根据i、j和v三元组生成m*n稀疏格式矩阵S
| 参数 | 类型 | 说明 |
|---|---|---|
i |
array of real | 存放矩阵行标的一元数组 |
j |
array of real | 存放矩阵列标的一元数组 |
v |
array of real | 存放矩阵元素值的一元数组 |
m |
integer | 矩阵的行数，整数 |
n |
integer | 矩阵的列数，整数 |
返回：array
示例
// 根据i,j,v三元组生成稀疏格式矩阵
i := array(0, 1, 2, 3);
j := array(3, 1, 4, 2);
v := array(5, 3, 2, 4);
return sparse2(i, j, v, 5, 5);
// 输出：
// array(
// (3:5),
// (1:3),
// (4:2),
// (2:4))
sparsefull(s, m, n)
声明：function
将稀疏矩阵格式转化为满矩阵，与Sparse1函数相对应
| 参数 | 类型 | 说明 |
|---|---|---|
s |
array of real | 稀疏格式矩阵 |
m |
integer | 转化为满矩阵的行数，整数 |
n |
integer | 转化为满矩阵的列数，整数 |
返回：array
示例
// 将S由稀疏格式矩阵转化为5*5满矩阵格式
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return sparsefull(s, 5, 5);
// 输出：
// array(
// (1,0,0,0,0),
// (0,0,0,0,0),
// (0,0,3,0,0),
// (0,0,0,4,0),
// (0,0,0,0,0))
sparseMatFill(a, fillv)
声明：function
稀疏数据表填充，直接在A矩阵上更改
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array,tablearray | 数据表类型，稀疏矩阵 |
fillv |
real | 实数，给定的填充值 |
返回：array,tablearray
示例
a := array((3: 4), ('A': 2));
sparseMatFill(a, -1);
return a; // 输出：array((3:4,"A":-1),(3:-1,"A":2))
spdiags1(a)
声明：function
提取矩阵非零对角线
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | Array,二维数组，原（稀疏）矩阵 |
返回：array
示例
// 提取矩阵A中非零对角线
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags1(a);
spdiags2(a, d)
声明：function
提取矩阵指定对角线
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | Array,二维数组，原（稀疏）矩阵 |
d |
array | Array,一维数组，对角线序列；也可以为数字； |
返回：array
示例
// 提取矩阵A中第-2,0,2条对角线，按列排列
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
d := array(-2, 0, 2);
return spdiags2(a, d);
spdiags3(b, d, a)
声明：function
根据指定列替换稀疏矩阵对角线
| 参数 | 类型 | 说明 |
|---|---|---|
b |
array | Array,二维数组，对角矩阵 |
d |
array | Array,一维数组，对角线序列 |
a |
array | Array,二维数组，原（稀疏）矩阵 |
返回：array
示例
// 将矩阵A中d指定的对角线替换为B中的列
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags3(b, d, a);
spdiags4(b, d, m, n)
声明：function
根据指定列创建稀疏矩阵
| 参数 | 类型 | 说明 |
|---|---|---|
b |
array | Array,二维数组，对角矩阵 |
d |
array | Array,一维数组，对角线序列 |
m |
integer | Integer,正整数，（稀疏）矩阵的行 |
n |
integer | Integer,正整数，（稀疏）矩阵的列 |
返回：array
示例
// 根据对角矩阵B创建稀疏带状矩阵
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
m := 5;
n := 5;
return spdiags4(b, d, m, n);
spnnz(s)
声明：function
稀疏矩阵S中的非零元素数目
| 参数 | 类型 | 说明 |
|---|---|---|
s |
array of real | 稀疏矩阵 |
返回：integer
示例
// 稀疏正态随机矩阵A中非零元素数目
a := sprandn2(5, 5, 0.2);
return spnnz(a); // 返回4（随机）
spnonzeros(s)
声明：function
提取稀疏矩阵S中的非零元素
| 参数 | 类型 | 说明 |
|---|---|---|
s |
array of real | 稀疏矩阵 |
返回：array
示例
// 提取稀疏正态随机矩阵A中非零元素
a := sprandn2(5, 5, 0.2);
return spnonzeros(a);
// 输出：一维数组，按顺序列出稀疏矩阵 a 中所有非零元素的值。
// 因 a 由 sprandn2 生成，非零元素个数与数值每次运行都不同。
spones(s, n)
声明：function
将稀疏矩阵S中的非零元素替换为n
| 参数 | 类型 | 说明 |
|---|---|---|
s |
array of real | 稀疏矩阵 |
n |
real | 非零元素被替换的值，实数 |
返回：array
示例
// 将S中非零元素替换为1
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return spones(s, 1);
// 输出：
// array(0:
// (1),2:
// (2:1),3:
// (3:1))
sprand1(s)
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数
| 参数 | 类型 | 说明 |
|---|---|---|
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)
声明：function
创建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)
声明：function
创建与矩阵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)
声明：function
创建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)
声明：function
创建与矩阵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)
声明：function
创建n*n稀疏正态随机矩阵，以下三角矩阵为基准对称正态分布随机矩阵，其中非零元素所占比例大约为pct
| 参数 | 类型 | 说明 |
|---|---|---|
n |
integer | 方阵的尺寸，整数 |
pct |
real | 方阵中非零元素所占比例，实数 |
返回：array
示例
// 创建10*10对称稀疏正态随机矩阵
a := sprandsym2(10, 0.2);
return a;
// 输出：10*10 对称稀疏矩阵，约 20% 位置非零，以下三角为基准对称，非零元素为正态随机数。
// 非零位置与数值每次运行都不同。
statByColumn(t, fname, _type)
声明：function
依据Type传递的字符串，返回字段Fname序列的type值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型，数据 |
fname |
string | 字符串，字段名称 |
_type |
string | 字符串，返回类型 |
返回：any
示例
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return statByColumn(s, 'a', 'MAX');
// 返回a列最大值:5
stdevByColumn(t, f_name)
声明：function
指定列的标准差
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名，字符串 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return stdevByColumn(t2, 'c');
// 输出：17.08
stockAmount(t, date, yes_value, change_field, item)
声明：function
在有序数据表 t 中，按 change_field 列定位最后一个不晚于 Date 的行（即 change_field <= Date 的最近一行），返回其 item 列的值；yes_value 决定取该行本身还是其前一行
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型，按 change_field 升序排列的数据表 |
date |
integer | 实数或日期，用于与 change_field 列比较的基准值 |
yes_value |
integer | 布尔值。0：返回命中行（Date 当期）；非 0：返回命中行的前一行 |
change_field |
string | 与 Date 比较的列名 |
item |
string | 返回值所在的列名 |
返回：any。命中行（或其前一行）中 item 列的值；若表中不存在不晚于 Date 的行，返回 0。
示例
t := array(
("变动日": 20110630, "收盘价": 90),
("变动日": 20120630, "收盘价": 60),
("变动日": 20130530, "收盘价": 33),
("变动日": 20110630, "收盘价": 90),
("变动日": 20130630, "收盘价": 30),
("变动日": 20140630, "收盘价": 20));
r1 := stockAmount(t, 20130630, 0, '变动日', '收盘价'); // Date当期
r2 := stockAmount(t, 20130630, 1, '变动日', '收盘价'); // 命中行的前一行
return array(r1, r2);
// 输出：array(30,90)
strSubscriptTableToNormal(t, fn)
声明：function
字符串下标数组-->索引下标数组
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 二维数组，数据 |
fn |
string | 字符串或数值，行标变成数据之后使用的列名 |
返回：array
示例
data := array("a": (1, 2), "b": (3, 4));
echo trim(toStn(strSubscriptTableToNormal(data, "source_index")));
sumValueByColumn(t, f_name)
声明：function
指定列中所有实数的和
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定字段 |
返回：real
示例
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return sumValueByColumn(t1, 'b');
// 输出：12
sumValueByColumn2(tb, column_name, from_row, to_row)
声明：function
求指定列中指定多行的和
| 参数 | 类型 | 说明 |
|---|---|---|
tb |
array | 数据表 |
column_name |
string | 指定字段 |
from_row |
integer | 指定计算起始行索引号（从0开始） |
to_row |
integer | 指定计算结束行索引号（从0开始） |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByColumn2(t2, 'c', 1, 2);
// 输出：76
sumValueByRow(tb, row_index)
声明：function
求指定行的和
| 参数 | 类型 | 说明 |
|---|---|---|
tb |
array | 数据表 |
row_index |
integer | 指定计算行索引号（从0开始） |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow(t2, 2);
// 输出：46
sumValueByRow2(tb, row_index, from_col, to_col)
声明：function
求指定行中指定多列的和
| 参数 | 类型 | 说明 |
|---|---|---|
tb |
array | 数据表 |
row_index |
integer | 指定计算行索引号（从0开始） |
from_col |
integer | 指定计算起始列索引号（从0开始） |
to_col |
integer | 指定计算起始列索引号（从0开始） |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow2(t2, 1, 0, 1);
// 输出：36
tableSelect(table, condition, reps)
声明：function
表格查询。从t中查询满足Condition的子表
| 参数 | 类型 | 说明 |
|---|---|---|
table |
any | 数据表 |
condition |
string | 字符串 |
reps |
string | 字符串 |
返回：array
示例
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return tableSelect(t, "~['b']=2", '~'); // 返回 t 中字段 'b'=2 的子表
// 输出：
tableVectorizeArray(t, s, opt, is_func)
声明：function
数据表与一维数据表的矢量化运算
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
s |
array|real | 一维数组 或实数， 运算标量 |
opt |
string | 字符串，操作运算符，默认"-",表逐行减法 |
is_func |
bool | 布尔，opt是否是函数，默认假 |
返回：array
示例
t := ones(10, 3);
s := array(1, 2, 3);
return tableVectorizeArray(t, s, '-');
// 输出：
// array(
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2))
TwoRDateCompare_M1(t1, t2, r_date, r_date2, key_field, from_col, to_col, show_g_value, show_g_percent)
声明：function
返回2个数据同比比较的结果
| 参数 | 类型 | 说明 |
|---|---|---|
t1 |
array | 数组类型，数据1 |
t2 |
array | 数组类型，数据2 |
r_date |
datetime | 报告期类型，报告期 |
r_date2 |
any | 报告期类型，同比报告期 |
key_field |
string | 字符串类型，关键字 |
from_col |
any | 整型，要显示变比的开始列号 |
to_col |
any | 整型，要显示变比的截止列号 |
show_g_value |
bool | 布尔类型，显示变动 |
show_g_percent |
bool | 布尔类型，显示变比(%) |
返回：array
示例
current_data := array(("code": "A", "value": 120));
previous_data := array(("code": "A", "value": 100));
echo trim(toStn(TwoRDateCompare_M1(
current_data,
previous_data,
20220331,
20210331,
"code",
0,
0,
true,
true
)));
unitary(t, key_fields, _type, f_value)
声明：function
归一处理。对数组t指定列KeyFields进行归一处理，归一方式由Type决定
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array,tablearray | |
key_fields |
string | |
_type |
integer | |
f_value |
integer |
返回：array,tablearray
示例
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
unitary(t, 'b', 0, 10);
return t;
// 输出：
// array(
// ("a":1,"b":10.0,"c":3,"d":4,"e":5,"f":7),
// ("a":2,"b":15.0,"c":4,"d":5,"e":6,"f":8),
// ("a":3,"b":20.0,"c":5,"d":6,"e":7,"f":9),
// ("a":4,"b":25.0,"c":6,"d":7,"e":8,"f":10))
varByColumn(t, f_name)
声明：function
指定列的方差
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表 |
f_name |
string | 指定列名，字符串 |
返回：real
示例
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return varByColumn(t2, 'c');
// 输出：291.67
zValue(t, column_name)
声明：function
按照指定字段求Z值
| 参数 | 类型 | 说明 |
|---|---|---|
t |
array | 数据表类型，数据表 |
column_name |
string | 字符串，要计算Rank的字段 |
返回：any
示例
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))