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