2506 lines
72 KiB
Markdown
2506 lines
72 KiB
Markdown
# Builtin - 基础 / 数组
|
||
|
||
## `getStrindexnum(value)`
|
||
|
||
返回字符串下标的个数
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ----- | -------- |
|
||
| `value` | array | 数组类型 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array("a1": 1, "a2": 2, 1: 3);
|
||
return getStrindexnum(arr);
|
||
// 输出：2
|
||
```
|
||
|
||
## `getstrindexs(value)`
|
||
|
||
返回数组类型，存储参数Value的所有的字符串下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ----- | -------- |
|
||
| `value` | array | 数组类型 |
|
||
|
||
返回：array of string
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array("a1": 1, "a2": 2, "a3": 3);
|
||
return getstrindexs(arr);
|
||
// 输出：array(“a1”,”a2”,”a3”)。
|
||
```
|
||
|
||
## `getintindexs(value)`
|
||
|
||
返回数组类型，存储数组Value的所有的数字下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ----- | -------- |
|
||
| `value` | array | 数组类型 |
|
||
|
||
返回：array of integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array(1: "p1", 2: "p2", 3: "p3", "a4": "p4");
|
||
return getintindexs(arr);
|
||
// 输出:array(1,2,3)
|
||
```
|
||
|
||
## `getAllIndexs(value)`
|
||
|
||
返回数组类型，存储数组Value的所有下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ----- | -------- |
|
||
| `value` | array | 数组类型 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array("p1": 1, "p2": 2, "p3": 3);
|
||
return getAllIndexs(arr); // 输出：array(“p1”,”p2”,”p3”)
|
||
```
|
||
|
||
## `length(value)`
|
||
|
||
返回字符串、二进制流或者数组或者Matrix的行长度。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ----------------------------- | ------------------------------------ |
|
||
| `value` | string\|binary\|array\|matrix | 字符串、二进制流或数组或者Matrix类型 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array(("p1": 1, "p2": 2, "p3": 3), ("p1": 4, "p2": 5, "p3": 6));
|
||
return length(arr); // 输出：2
|
||
```
|
||
|
||
## `sortTableByField(value, field, sortdir)`
|
||
|
||
对一个表类型的数组Value用字段名Field排序，排序方向由sortdir决定，如果省略sortdir参数或者设置sortdir为1，正序排序，否则逆序排序。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------- | ------ | ---------------------------------------- |
|
||
| `value` | array | 二维数组； |
|
||
| `field` | string | 字符串，数组的列下标； |
|
||
| `sortdir` | bool | 布尔型，排序方向，1表示正序，0表示逆序。 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array(
|
||
("p1": 1, "p2": 2, "p3": 3),
|
||
("p1": 4, "p2": 5, "p3": 6),
|
||
("p1": 66, "p2": 200, "p3": 36),
|
||
("p1": 30, "p2": 500, "p3": 40)
|
||
);
|
||
sortTableByField(arr, "p1", 1); // sortdir=1按"p1"正序，sortdir=0反序
|
||
return arr;
|
||
// 输出：
|
||
// array(
|
||
// ("p1":1, "p2":2, "p3":3),
|
||
// ("p1":4, "p2":5, "p3":6),
|
||
// ("p1":30, "p2":500, "p3":40),
|
||
// ("p1":66, "p2":200, "p3":36))
|
||
```
|
||
|
||
## `filterIn(r, v, field, b_return_sub_result=true)`
|
||
|
||
返回指定列的值在过滤集内的子结果集或者下标列表。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------------------- | ------ | ------------------------------------------------------------------------------ |
|
||
| `r` | array | 待过滤的数据表或数组。 |
|
||
| `v` | array | 过滤集。 |
|
||
| `field` | string | 指定列名；为 `nil` 时按整行或一维数组元素匹配。 |
|
||
| `b_return_sub_result` | bool | 可选参数，默认 `true`。为 `true` 时返回子结果集，为 `false` 时返回行下标列表。 |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
范例 01：过滤表中指定列的值。
|
||
|
||
```tsl
|
||
a := array(
|
||
("a": 0, "b": 0, "c": 0),
|
||
("a": 1, "b": 0, "c": 2),
|
||
("a": 2, "b": 1, "c": 4),
|
||
("a": 3, "b": 1, "c": 6),
|
||
("a": 4, "b": 2, "c": 8),
|
||
("a": 5, "b": 2, "c": 10),
|
||
("a": 6, "b": 3, "c": 12)
|
||
);
|
||
return filterIn(a, array(1, 2, 5), "a");
|
||
// 输出：array(
|
||
// ("a":1, "b":0, "c":2),
|
||
// ("a":2, "b":1, "c":4),
|
||
// ("a":5, "b":2, "c":10)
|
||
// )
|
||
```
|
||
|
||
范例 02：按整行数据筛选子集。
|
||
|
||
```tsl
|
||
a := array();
|
||
for i := 0 to 15 do
|
||
begin
|
||
a[i]["a"] := i;
|
||
a[i]["b"] := i div 2;
|
||
a[i]["c"] := i * 2;
|
||
end;
|
||
return filterIn(a, array(("a": 2, "b": 1, "c": 4), ("a": 3, "b": 1, "c": 4)), nil);
|
||
// 输出：array(
|
||
// ("a":2, "b":1, "c":4)
|
||
// )
|
||
```
|
||
|
||
范例 03：按多列组合筛选子集。
|
||
|
||
```tsl
|
||
a := array();
|
||
for i := 0 to 15 do
|
||
begin
|
||
a[i]["a"] := i;
|
||
a[i]["b"] := i div 2;
|
||
a[i]["c"] := i * 2;
|
||
end;
|
||
return filterIn(a, array(("a": 2, "b": 1), ("a": 3, "b": 1)), array("a", "b"));
|
||
// 输出：array(
|
||
// ("a":2, "b":1, "c":4),
|
||
// ("a":3, "b":1, "c":6)
|
||
// )
|
||
```
|
||
|
||
范例 04：返回符合指定列数据的行下标。
|
||
|
||
```tsl
|
||
a := array();
|
||
for i := 0 to 15 do
|
||
begin
|
||
a[i]["a"] := i;
|
||
a[i]["b"] := i div 2;
|
||
a[i]["c"] := i * 2;
|
||
end;
|
||
return filterIn(a, array(("a": 2, "b": 1), ("a": 3, "b": 1)), array("a", "b"), false);
|
||
// 输出：array(2, 3)
|
||
```
|
||
|
||
范例 05：过滤一维数组。
|
||
|
||
```tsl
|
||
return filterIn(array(1, -5, 10, 2, 10, 14, -5), array(2, 3, 10), nil);
|
||
// 输出：array(10, 2, 10)
|
||
```
|
||
|
||
## `filterNotIn(r, v, field, b_return_sub_result=true)`
|
||
|
||
返回指定列的值不在过滤集内的子结果集或者下标列表。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------------------- | ------ | ------------------------------------------------------------------------------ |
|
||
| `r` | array | 待过滤的数据表或数组。 |
|
||
| `v` | array | 过滤集。 |
|
||
| `field` | string | 指定列名；为 `nil` 时按整行或一维数组元素匹配。 |
|
||
| `b_return_sub_result` | bool | 可选参数，默认 `true`。为 `true` 时返回子结果集，为 `false` 时返回行下标列表。 |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
范例 01：按指定列过滤数据表，并同时查看子结果集和行下标。
|
||
|
||
```tsl
|
||
a := array();
|
||
for i := 0 to 5 do
|
||
begin
|
||
a[i]["a"] := i;
|
||
a[i]["b"] := i div 2;
|
||
a[i]["c"] := i * 2;
|
||
end;
|
||
b := array(1, 3, 5);
|
||
c1 := filterNotIn(a, b, "a"); // 过滤结果
|
||
c2 := filterNotIn(a, b, "a", false); // 过滤仅返回下标
|
||
return array(c1, c2);
|
||
// 输出：
|
||
// array(
|
||
// (
|
||
// ("a":0, "b":0, "c":0),
|
||
// ("a":2, "b":1, "c":4),
|
||
// ("a":4, "b":2, "c":8)),
|
||
// (0, 2, 4))
|
||
```
|
||
|
||
范例 02：按整行数据过滤二维数组，保留重复行。
|
||
|
||
```tsl
|
||
t := array(
|
||
("a": 0, "b": 0, "c": 0),
|
||
("a": 1, "b": 0, "c": 2),
|
||
("a": 2, "b": 1, "c": 4),
|
||
("a": 2, "b": 1, "c": 4),
|
||
("a": 4, "b": 2, "c": 8),
|
||
("a": 4, "b": 2, "c": 8),
|
||
("a": 6, "b": 3, "c": 12)
|
||
);
|
||
return filterNotIn(t, array(("a": 2, "b": 1, "c": 4)), nil);
|
||
// 输出：
|
||
// array(
|
||
// ("a":0, "b":0, "c":0),
|
||
// ("a":1, "b":0, "c":2),
|
||
// ("a":4, "b":2, "c":8),
|
||
// ("a":4, "b":2, "c":8),
|
||
// ("a":6, "b":3, "c":12))
|
||
```
|
||
|
||
范例 03：过滤一维数组。
|
||
|
||
```tsl
|
||
return filterNotIn(array(1, -5, 10, 2, 10, 14, -5), array(2, 3, 10), nil);
|
||
// 输出：array(1, -5, 14, -5)
|
||
```
|
||
|
||
## `sortArray(value, sortdir)`
|
||
|
||
对一个一维数组进行排序，方向为sortdir；如果省略sortdir参数，默认为1，正序排序；设置为0时，逆序排序。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------- | ----- | ---------------- |
|
||
| `value` | array | 一维数组 |
|
||
| `sortdir` | bool | 布尔型，排序方向 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
arr := array(1, 6, 3);
|
||
sortArray(arr);
|
||
return arr;
|
||
// array(1,3,6)
|
||
```
|
||
|
||
## `reIndex(data, index_info1, index_info2, index_info_n)`
|
||
|
||
修改数组下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------------- | ---------- | ------------------------------------------------------------------------------------------- |
|
||
| `data` | array | 需要重构的数组 |
|
||
| `index_info1` | nil\|array | 第一维的重构信息，如果为NIL则表示该维度不重构，数组以需要重构的下标为下标新下标为值的模式。 |
|
||
| `index_info2` | nil\|array | 第二维的重构信息，可省略 |
|
||
| `index_info_n` | nil\|array | 第N维的重构信息，可省略 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 修改数字列名数组为字符串列名数组，即将0,1,2(自增数字）列名重构为"a","b","c"列名的数组
|
||
a := rand(10, 3);
|
||
s := array("a", "b", "c");
|
||
reIndex(a, nil, s);
|
||
return a;
|
||
// 修改数字行标数组为字符串行标数组，即将0,1,2(自增数字）行标重构为"a","b","c"行标的数组
|
||
a := rand(3, 3);
|
||
s := array("a", "b", "c");
|
||
reIndex(a, s);
|
||
return a;
|
||
// 通过设置行标为nil进行删除该行记录
|
||
a := array("A": 0, "B": 1, "D": 2, "E": 3);
|
||
reIndex(a, array("A": "A1", "D": nil));
|
||
return a;
|
||
// 返回：array("A1":0,"B":1,"E":3);
|
||
// 如果我们要对多维数组进行处理
|
||
a := rand(10, array("A", "B", "D", "E"); // 初始化一个四列的二维矩阵
|
||
reIndex(a, nil, array("A": "A1", "D": nil));
|
||
return a;
|
||
// 说明，第2个参数为nil表示对第一维的下标不进行变动，因此我们修改列"A"为"A1",并删除"D"列。
|
||
// 利用Reindex做列的交换
|
||
a := array(1, 2, 3, 4, 5);
|
||
reIndex(a, array(0: 4, 4: 0));
|
||
return a;
|
||
// 结果为array(5,2,3,4,1);
|
||
```
|
||
|
||
## `fieldNamesOfStrSubscript(t)`
|
||
|
||
字符串下标数组的字段名称。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | ---- |
|
||
| `t` | array | 整数 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
|
||
return fieldNamesOfStrSubscript(s);
|
||
// 返回:
|
||
```
|
||
|
||
## `fieldCountOfStrSubscript(t)`
|
||
|
||
字符串下标数组的字段个数。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | ---------- |
|
||
| `t` | array | 数据表类型 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
|
||
return fieldCountOfStrSubscript(s);
|
||
// 返回：4
|
||
```
|
||
|
||
## `argmax(x)`
|
||
|
||
1、返回一维数组中最大值所在下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ---------------- | ------------ |
|
||
| `x` | array,tablearray | 一维数字数组 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
x := array(9, 8, 10);
|
||
return argmax(x); // 2
|
||
```
|
||
|
||
## `argmin(x)`
|
||
|
||
1、返回一维数组中最小值所在下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ---------------- | ------------ |
|
||
| `x` | array,tablearray | 一维数字数组 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
x := array(3, 1, 9, 2);
|
||
return argmin(x); // 1
|
||
```
|
||
|
||
## `sortTableByFieldExt(t, sort_field)`
|
||
|
||
将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------ | ------ | ---------------- |
|
||
| `t` | array | 数据表类型，数组 |
|
||
| `sort_field` | string | 字符串,排序字段 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
|
||
return sortTableByFieldExt(s, 'b');
|
||
// 返回:
|
||
```
|
||
|
||
## `rankValue(t, fields)`
|
||
|
||
按照指定字段求Rank,返回的数据，保存在传递过来的数据t中。返回按Fields列排序的结果，
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ------------------ |
|
||
| `t` | array | 数据表类型，数据表 |
|
||
| `fields` | string | 字符串，排序的列 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 取上证50的成分股，获得涨幅之后，对涨幅进行排名
|
||
stock_arr := getBkByDate('SH000016', 20190201T);
|
||
s := select ['StockID'] as '代码',
|
||
["StockName"] as "名称",
|
||
['price'] as '收盘',
|
||
stockZf(['date'], ['date']) as '涨幅(%)'
|
||
from markettable datekey 20190201T to 20190201T of stockArr end;
|
||
rankValue(s, '涨幅(%)');
|
||
return s;
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:getBkByDate compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `argsort(value, sortdir)`
|
||
|
||
返回可以用于排序的一维数组下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------- | ------- | --------------------------------------- |
|
||
| `value` | array | 一维数字数组，数组 |
|
||
| `sortdir` | integer | 整数，排序方向（1:正序【默认】;0:逆序） |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
value := array(4, 8, 2, 3, 9);
|
||
return argsort(value); // 返回：array(2,3,0,1,4)
|
||
```
|
||
|
||
## `rankIt(t, f_n, sort_order)`
|
||
|
||
按指定字段的值排名；SortOrder：0 降序排名；SortOrder：1升序排名
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------ | ------- | ------------------------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_n` | string | 字段名 |
|
||
| `sort_order` | integer | 排名方向，0 降序排名, 1升序排名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
|
||
rankIt(t2, 'c', 1);
|
||
return t2;
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:rankIt compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `rankIt2(t, f_n, of_n, sort_order)`
|
||
|
||
按指定字段的值排名，SortOrder:0 降序排名；SortOrder:1 升序排名，排名列的字段为：OfN
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------ | ------- | ------------------------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_n` | string | 指定字段，字符串 |
|
||
| `of_n` | string | 排名列字段名，字符串 |
|
||
| `sort_order` | integer | 排名方向:0 降序排名，1 升序排名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
|
||
rankIt2(t2, 'c', '名次', 1);
|
||
return t2;
|
||
// 输出：
|
||
// 示例包含说明文字，未作为可执行片段运行。
|
||
```
|
||
|
||
## `rpsIt(t, f_n, sort_order)`
|
||
|
||
按指定字段的值排名，获得其排名的百分位，排序百分位放在列 FN+"\_RPS"中；
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------ | ------- | ------------------------------- |
|
||
| `t` | array | 数组，数据表 |
|
||
| `f_n` | string | 字符串/数字，字段名 |
|
||
| `sort_order` | integer | 排名方向，0 降序排名, 1升序排名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 获得沪深300的成分股，并计算EndT的涨幅，对涨幅排序后返回其排序百分比。
|
||
endt := intToDate(20140401);
|
||
setSysParam(PN_Date(), end_t);
|
||
stock_arr := getBkByDate('SH000300', end_t);
|
||
r := array();
|
||
n := 0;
|
||
for n_i := 0 to length(stock_arr)-1 do
|
||
begin
|
||
stock_id := stock_arr[n_i];
|
||
setSysParam(pn_stock(), stock_id);
|
||
if not isTradeDay(end_t) then continue;
|
||
r[n]['StockID'] := stock_id;
|
||
r[n]['StockName'] := stockName(stock_id);
|
||
r[n]['StockZF'] := stockZf3();
|
||
n++;
|
||
end;
|
||
return rpsIt(r, 'StockZF', 1);
|
||
// 部分结果截图：
|
||
```
|
||
|
||
## `deleteNilValueByField(t, fields)`
|
||
|
||
删除指定字段fields数据为NIL的记录。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | --------------------------------------------------------------- |
|
||
| `t` | array | 数据表类型，数据 |
|
||
| `fields` | string | 字符串，字段名称，多个字段用分号（;）连接，例:＂Field1;Field2＂ |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
tdata := array(array('time': 1, 'price': 7.78), array('time': 2));
|
||
deleteNilValueByField(tdata, 'price');
|
||
return tdata;
|
||
// 返回:
|
||
```
|
||
|
||
## `inserttablebyrno(t, index, rdata)`
|
||
|
||
向表格指定位置插入行，天软表格行下标从0开始
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ------- | ------------------------------------------------------------ |
|
||
| `t` | array | Array,数组，支持一维，二维数组，只支持下标为自增长的序列数组 |
|
||
| `index` | integer | Integer,插入行的起始下标，下标位置从０开始 |
|
||
| `rdata` | any | Any,插入的数据，支持一个值、一维表及二维表 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
范例1：
|
||
|
||
```tsl
|
||
// 向一维数组指定位置插入一个字符串’aaa’
|
||
t := 43456->43460;
|
||
index := 2;
|
||
r_data := 'aaa';
|
||
return inserttablebyrno(t, index, r_data);
|
||
// 结果：array(43456,43457,"aaa",43458,43459,43460)
|
||
```
|
||
|
||
范例2：
|
||
|
||
```tsl
|
||
// 向一维数组第3行插入多行的数据
|
||
t := 44000->44004;
|
||
index := 3;
|
||
r_data := array('a', 'b', 'c');
|
||
return inserttablebyrno(t, index, r_data);
|
||
// 结果：
|
||
array(44000, 44001, 44002, "a", "b", "c", 44003, 44004)
|
||
```
|
||
|
||
范例3：
|
||
|
||
```tsl
|
||
// 向二维数组第3行插入多行的数据
|
||
t := array(('a': 10, 'b': 'i', 'c': dateToStr(20200319T)),
|
||
('a': 50, 'b': 'i', 'c': dateToStr(20200318T)),
|
||
('a': 60, 'b': 'i', 'c': dateToStr(20200317T)),
|
||
('a': 40, 'b': 'o', 'c': dateToStr(20200316T)),
|
||
('a': 20, 'b': 'o', 'c': dateToStr(20200313T)));
|
||
index := 3;
|
||
r_data := array(('c': 0, 'b': 44000, 'a': '2020-03-20'));
|
||
return inserttablebyrno(t, index, r_data);
|
||
// 输出：
|
||
// Execute script error at Line:9
|
||
// function:__main__:line 9:instruction:usercall: function:inserttablebyrno compile error or not found
|
||
// function:__main__:line 9:instruction:usercall: function execute error
|
||
```
|
||
|
||
范例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);
|
||
// 输出：
|
||
// Execute script error at Line:10
|
||
// function:__main__:line 10:instruction:usercall: function:inserttablebyrno compile error or not found
|
||
// function:__main__:line 10:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `arrayextend(a, ind, v)`
|
||
|
||
数组-指定位置插入子集
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | --------------- | ---------------------------- |
|
||
| `a` | array of number | Array of number,一维数字数组 |
|
||
| `ind` | integer | Integer,插入的起始位置 |
|
||
| `v` | array of number | Array of number,插入的子数组 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
a := letters(1->6);
|
||
return arrayextend(a, 2, array('d', 'e'));
|
||
// 返回：array("A", "B", "d", "e", "C", "D", "E", "F")
|
||
```
|
||
|
||
## `arrayinsert(a, ind, v)`
|
||
|
||
数组-指定位置插入值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | --------------- | ---------------------------- |
|
||
| `a` | array of number | Array of number,一维数字数组 |
|
||
| `ind` | integer | Integer,插入位置 |
|
||
| `v` | any | Any,元素值 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
a := letters(1->6);
|
||
return arrayinsert(a, 2, 3);
|
||
// 返回：array("A", "B", 3, "C", "D", "E", "F")
|
||
```
|
||
|
||
## `frameinsert(data, loc, fname, v)`
|
||
|
||
数据表-指定位置插入列
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ------- | ----------------------- |
|
||
| `data` | table | Table,二维数据表,源数据 |
|
||
| `loc` | integer | Integer,插入位置 |
|
||
| `fname` | string | String,插入索引命名 |
|
||
| `v` | integer | Integer,插入值 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
data := load_dataset_iris();
|
||
return frameinsert(data, 1, '新列', 0);
|
||
```
|
||
|
||
## `searchsorted(v, x)`
|
||
|
||
有序列表插入指定值的位置，原数组必须为有序表且元素应可比较。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | -------------- | ----------------- |
|
||
| `v` | array | 一维数组 有序数组 |
|
||
| `x` | string \| real | 插入的值 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 数字插入
|
||
v := array(1, 2, 3, 4, 5, 6);
|
||
return searchsorted(v, 3.5); // 返回：3
|
||
// 字符串插入
|
||
v := array("SH600001", "SH600004", "SH600050", "SH600305");
|
||
return searchsorted(v, "SH600049"); // 返回：2
|
||
```
|
||
|
||
## `argconfirst(a, v, _type)`
|
||
|
||
第一次满足条件的位置, 原数组必须为有序表且元素应可比较。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ------------------- | -------- |
|
||
| `a` | array | 有序数组 |
|
||
| `v` | string\|real\|array | 对比值 |
|
||
| `_type` | integer | 对比条件 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 实数对比
|
||
a := 0->9;
|
||
return argconfirst(a, 3.5, 1); // 返回：4
|
||
// 数组对比
|
||
a := array(("a", "A"), ("b", "B"), ("c", "C"), ("d", "D"));
|
||
v := array("b", "B");
|
||
return argconfirst(a, v, 6); // 返回：1
|
||
```
|
||
|
||
## `stockAmount(t, date, yes_value)`
|
||
|
||
从数据表t中获取符合ChangeField大于或等于Date的数据。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----------- | ------- | ---------------------------------------------- |
|
||
| `t` | array | 数据表类型，需要比较获取的数据表 |
|
||
| `date` | integer | 实数，或者日期 |
|
||
| `yes_value` | integer | 布尔值，决定返回Date当天的数据还是之前的数据； |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 平安银行2011年6月30日流通A股发生变动
|
||
setSysParam(PN_Stock(), 'SZ000001');
|
||
t := infoArray(16); // 股票.股本结构表
|
||
r1 := stockAmount(t, 20110630, 0, '变动日', '流通A股'); // Date当天
|
||
r2 := stockAmount(t, 20110630, 1, '变动日', '流通A股'); // Date之前
|
||
return array(r1, r2);
|
||
// 结果：array(3105358672.0,3105358511.0)
|
||
```
|
||
|
||
## `seperateTable(t, sep_field, sep_count)`
|
||
|
||
把表格t分割为SepCount个表格。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----------- | ------- | -------------------- |
|
||
| `t` | array | 数据表类型，原始数组 |
|
||
| `sep_field` | string | 字符串，排序字段 |
|
||
| `sep_count` | integer | 整数，分割数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
|
||
return seperateTable(t, 'a', 2);
|
||
// 返回:
|
||
```
|
||
|
||
## `unitary(t, key_fields, _type, f_value)`
|
||
|
||
归一处理。对数组t指定列KeyFields进行归一处理，归一方式由Type决定。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------ | ---------------- | ---- |
|
||
| `t` | array,tablearray | |
|
||
| `key_fields` | string | |
|
||
| `_type` | integer | |
|
||
| `f_value` | integer | |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
|
||
unitary(t, 'b', 0, 10);
|
||
return t;
|
||
// 返回:
|
||
```
|
||
|
||
## `tableVectorizeArray(t, s, opt, is_func)`
|
||
|
||
数据表与一维数据表的矢量化运算。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------- | ----------- | -------------------------------------- |
|
||
| `t` | array | 数据表 |
|
||
| `s` | array\|real | 一维数组 或实数， 运算标量 |
|
||
| `opt` | string | 字符串，操作运算符，默认"-",表逐行减法 |
|
||
| `is_func` | bool | 布尔，opt是否是函数，默认假 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := ones(10, 3);
|
||
s := array(1, 2, 3);
|
||
return tableVectorizeArray(t, s, '-');
|
||
// 输出：
|
||
// Execute script error at Line:3
|
||
// function:__main__:line 3:instruction:usercall: function:tableVectorizeArray compile error or not found
|
||
// function:__main__:line 3:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `reverse(arr)`
|
||
|
||
数组倒置反向。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ----- | ---- |
|
||
| `arr` | array | 数组 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 倒置数组
|
||
setSysParam(pn_stock(), "SZ000002");
|
||
setSysParam(pn_date(), 20210601t);
|
||
arr := nDay(10, "date", dateToStr(sp_time()), "close", close());
|
||
return reverse(arr);
|
||
// 输出：
|
||
// Execute script error at Line:5
|
||
// function:__main__:line 5:instruction:usercall: function:reverse compile error or not found
|
||
// function:__main__:line 5:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `descartesJoin(v1, v2, v_n)`
|
||
|
||
数组笛卡尔积连接。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ---- | --------------------------------- |
|
||
| `v1` | | 任意类型，支持不定个数参数，数值1 |
|
||
| `v2` | | 任意类型，数值2 |
|
||
| `v_n` | | 任意类型，数值3 |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
return descartesJoin(1->3, 21->22, 3);
|
||
// 输出：
|
||
// Execute script error at Line:1
|
||
// function:__main__:line 1:instruction:->: function:descartesJoin compile error or not found
|
||
// function:__main__:line 1:instruction:->: function execute error
|
||
```
|
||
|
||
## `abnormalData(y, flag, ystore)`
|
||
|
||
数组中出现奇异值的处理。其中y为数据表，Flag为处理方法，Ystore为选择中位数和3倍标准差法返回被处理数据的数据。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ------------------------------------------------------------ |
|
||
| `y` | array | 一维数字数组 |
|
||
| `flag` | string | 用户自定义，奇异值处理方法 |
|
||
| `ystore` | array | 数据表类型，存放修改的数据，包括修改的行、原数值、处理后的值 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
范例01：返回奇异值的位置及处理后的结果。
|
||
|
||
```tsl
|
||
t := array(1, 100, 101, 102, 103, 1000);
|
||
abnormalData(t, "median", r);
|
||
return r;
|
||
// 返回:
|
||
// 其中，0和5为修改的行，1和1000是对应的原值，93.7和109.3是修改后的值
|
||
```
|
||
|
||
范例02：对源数据列增加一列奇异值处理后的结果
|
||
|
||
```tsl
|
||
col := 'SH000001';
|
||
setSysParam(pn_stock(), col);
|
||
setSysParam(pn_date(), 20240930T);
|
||
setSysParam(pn_cycle(), cy_day());
|
||
days := 100;
|
||
// SH000001在20240930最近100天的行情数据中设置三个奇异值
|
||
t := nDay(days, '日期', dateToStr(sp_time()), col, close());
|
||
t[29, col] := 1500;
|
||
t[59, col] := 4500;
|
||
t[79, col] := 6000;
|
||
// 找到数组指定列奇异值，以中位数法为例
|
||
tyc := abnormalData(t[: , col], "median", abn);
|
||
t[: , col$"_奇异值处理"] := tyc;
|
||
return t;
|
||
// 输出：增加列"SH000001_奇异值处理"
|
||
```
|
||
|
||
## `zValue(t, column_name)`
|
||
|
||
按照指定字段求Z值。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------- | ------ | ------------------------ |
|
||
| `t` | array | 数据表类型，数据表 |
|
||
| `column_name` | string | 字符串，要计算Rank的字段 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
stock_arr := getBkByDate('SH000016', 20190201T);
|
||
s := select ['StockID'] as '代码',
|
||
["StockName"] as "名称",
|
||
['price'] as '收盘',
|
||
stockZf(['date'], ['date']) as '涨幅(%)'
|
||
from markettable datekey 20190201T to 20190201T of stockArr end;
|
||
zValue(s, '涨幅(%)');
|
||
return s
|
||
// 返回:
|
||
```
|
||
|
||
## `rpsValue(t, column_name)`
|
||
|
||
按照指定字段求RPS。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------- | ------ | ----------------------- |
|
||
| `t` | array | 数据表类型，数据表 |
|
||
| `column_name` | string | 字符串，要计算RPS的字段 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
stock_arr := getBkByDate('SH000016', 20190201T);
|
||
s := select ['StockID'] as '代码',
|
||
["StockName"] as "名称",
|
||
['price'] as '收盘',
|
||
stockZf(['date'], ['date']) as '涨幅(%)'
|
||
from markettable datekey 20190201T to 20190201T of stockArr end;
|
||
rpsValue(s, '涨幅(%)');
|
||
return s;
|
||
// 返回:
|
||
```
|
||
|
||
## `webFormatToRung(a)`
|
||
|
||
将数组Nan/Nil/±Inf替换为"-"
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | -------------------------------------------- |
|
||
| `a` | array | 数组，待替换数组，支持多维数组，高维嵌套数组 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
a := array('a': ('b': ('c': (nil, nan, 3), 'd': 2), 'e': nan));
|
||
return webFormatToRung(a); // array("a":("b":("c":("-","-",3),"d":2),"e":"-"))
|
||
```
|
||
|
||
## `factorize(value, ifsort, nan_fill_value, uniques)`
|
||
|
||
分类变量数值映射，将一个一维分类变量数组映射为给分类变量递增编号后的数值数组
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---------------- | ----- | ---------------------------------- |
|
||
| `value` | array | 数组，一维数组 |
|
||
| `ifsort` | bool | 布尔型，是否排序，默认不排序 |
|
||
| `nan_fill_value` | any | 数字/字符串，填充nan的值，默认为-1 |
|
||
| `uniques` | array | 数组，输出，各值对应的原值 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
value := Array('a', 'd', 'c', 'a', 'b');
|
||
labels := factorize(value, true, -1, uniques);
|
||
echo uniques; // array("a","b","c","d")
|
||
return labels; // array(0,3,2,0,1);
|
||
```
|
||
|
||
## `sparseMatFill(a, fillv)`
|
||
|
||
稀疏数据表填充，直接在A矩阵上更改
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ---------------- | -------------------- |
|
||
| `a` | array,tablearray | 数据表类型，稀疏矩阵 |
|
||
| `fillv` | real | 实数，给定的填充值 |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
a := array((3: 4), ('A': 2));
|
||
sparseMatFill(a, -1);
|
||
return a; // array((3:4,"A":-1),(3:-1,"A":2))
|
||
```
|
||
|
||
## `elementWhere(con, x, y)`
|
||
|
||
根据布尔数组con,为True时从X中，为False时从Y中，取对应位置元素的值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ---------------- | ---- |
|
||
| `con` | array,tablearray | |
|
||
| `x` | array,tablearray | |
|
||
| `y` | array,tablearray | |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
con := array(1, 0, 1, 1, 1, 0);
|
||
x := array(1, 2, 3, 4, 5, 6);
|
||
y := array(11, 12, 13, 14, 15, 16);
|
||
return elementWhere(con, x, y); // array(1,12,3,4,5,16)
|
||
```
|
||
|
||
## `arrayAddGap(t, key, v, m)`
|
||
|
||
数组添加分割线,只支持字符串下标
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ------- | ------------------------------------------- |
|
||
| `t` | array | 数组，待添加数组，直接在原数组更改 |
|
||
| `key` | string | 字符串，间隔名，默认无 |
|
||
| `v` | string | 字符串，间隔串，默认为 DupeString('-',m\*2) |
|
||
| `m` | integer | 整型，间隔串的长度设置，默认 5 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
a := array('alpha(%)': 3);
|
||
arrayAddGap(a, '风险');
|
||
a['beta'] := 3;
|
||
return a; // array("alpha(%)":3,"-----风险-----":"----------","beta":3)
|
||
```
|
||
|
||
## `groupPercentrankIt(t, g_name, v_name)`
|
||
|
||
计算分组百分位，对数据表t按[GName]分组后，对每组的[Vname_]计算百分位
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ------------------ |
|
||
| `t` | array | 数组，待计算的数组 |
|
||
| `g_name` | string | 字符串，分组字段名 |
|
||
| `v_name` | string | 字符串，转换字段名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
|
||
("G": 0, "V1": 2, "V2": 12, "V3": 22),
|
||
("G": 1, "V1": 3, "V2": 13, "V3": 23),
|
||
("G": 0, "V1": 4, "V2": 14, "V3": 24),
|
||
("G": 1, "V1": 5, "V2": 15, "V3": 25),
|
||
("G": 0, "V1": 6, "V2": 16, "V3": 26));
|
||
return groupPercentrankIt(t, 'G', 'V1'); // array(0.0,0.0,0.5,0.5,1.0,1.0)
|
||
```
|
||
|
||
## `groupRankIt(t, g_name, v_name, sort_order)`
|
||
|
||
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]计算排名
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------ | ------ | ------------------ |
|
||
| `t` | array | 数组，待计算的数组 |
|
||
| `g_name` | string | 字符串，分组字段名 |
|
||
| `v_name` | string | 字符串，转换字段名 |
|
||
| `sort_order` | bool | 布尔型，排名方向 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := array(
|
||
("G": 1, "V1": 1, "V2": 11, "V3": 21),
|
||
("G": 0, "V1": 2, "V2": 12, "V3": 22),
|
||
("G": 1, "V1": 3, "V2": 13, "V3": 23),
|
||
("G": 0, "V1": 4, "V2": 14, "V3": 24),
|
||
("G": 1, "V1": 5, "V2": 15, "V3": 25),
|
||
("G": 0, "V1": 6, "V2": 16, "V3": 26));
|
||
return groupRankIt(t, 'G', 'V1'); // array(1,1,2,2,3,3)
|
||
```
|
||
|
||
## `groupTransformByFunc(t, g_name, v_name, fp)`
|
||
|
||
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]根据给定函数进行分组转换操作
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | --------------------------------------------------------------------------------------------------- |
|
||
| `t` | array | 数组，待计算的数组 |
|
||
| `g_name` | string | 字符串，分组字段名 |
|
||
| `v_name` | string | 字符串或数组，转换字段名 |
|
||
| `fp` | string | 字符串（函数名）或函数指针，转换函数必须两个参数，分别表示当前的聚合字段与排名字段，以分组排名为例: |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
|
||
("G": 0, "V1": 2, "V2": 12, "V3": 22),
|
||
("G": 1, "V1": 3, "V2": 13, "V3": 23),
|
||
("G": 0, "V1": 4, "V2": 14, "V3": 24),
|
||
("G": 1, "V1": 5, "V2": 15, "V3": 25),
|
||
("G": 0, "V1": 6, "V2": 16, "V3": 26));
|
||
fp := function (v, g);
|
||
begin
|
||
return rankof([v], [v]);
|
||
end
|
||
return groupTransformByFunc(t, 'G', 'V1', fp); // array(3,3,2,2,1,1)
|
||
```
|
||
|
||
## `frameGetSubByReg(data, reg)`
|
||
|
||
通过正则表达式匹配获取数据框子集
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | ------ | -------------------------- |
|
||
| `data` | array | 数组，待匹配的数组 |
|
||
| `reg` | string | 字符串，间隔名，正则匹配串 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := array((13: 1, "V1": 1, "V2": 11, 12: 21, 'R1w': 1),
|
||
(13: 0, "V1": 2, "V2": 12, 12: 22, 'R1w': 1),
|
||
(13: 1, "V1": 3, "V2": 13, 12: 23, 'R1w': 1),
|
||
(13: 0, "V1": 4, "V2": 14, 12: 24, 'R1w': 1),
|
||
(13: 1, "V1": 5, "V2": 15, 12: 25, 'R1w': 1),
|
||
(13: 0, "V1": 6, "V2": 16, 12: 26, 'R1w': 1));
|
||
return frameGetSubByReg(t, '1');
|
||
// 结果：
|
||
array(
|
||
(21, 1, "V1": 1, "R1w": 1),
|
||
(22, 0, "V1": 2, "R1w": 1),
|
||
(23, 1, "V1": 3, "R1w": 1),
|
||
(24, 0, "V1": 4, "R1w": 1),
|
||
(25, 1, "V1": 5, "R1w": 1),
|
||
(26, 0, "V1": 6, "R1w": 1))
|
||
```
|
||
|
||
## `histogram(t, bins, format)`
|
||
|
||
统计data的频数分布表
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ---------------- | --------------------------------------- |
|
||
| `t` | array,tablearray | 数字数组，待计算的数组 |
|
||
| `bins` | array,tablearray | 数组，表分组间隔 |
|
||
| `format` | string | 字符串，展示区间的格式串，见FormatFloat |
|
||
|
||
返回：array,tablearray
|
||
|
||
### 示例
|
||
|
||
范例一：
|
||
|
||
```tsl
|
||
return histogram(Randn(0, 1, 1000), array(-3, 0.5)->3, '0.00');
|
||
// 输出：
|
||
// Execute script error at Line:1
|
||
// function:__main__:line 1:instruction:usercall: function:Randn compile error or not found
|
||
// function:__main__:line 1:instruction:usercall: function execute error
|
||
```
|
||
|
||
范例二：
|
||
|
||
```tsl
|
||
data := randn(0, 1, 1000, array('a', 'b'));
|
||
return histogram(data, array(-3, 0.5)->3, '0.00');
|
||
// 输出：
|
||
// Execute script error at Line:1
|
||
// function:__main__:line 1:instruction:array: function:randn compile error or not found
|
||
// function:__main__:line 1:instruction:array: function execute error
|
||
```
|
||
|
||
## `framemerge(left, right, ons, how)`
|
||
|
||
数据表-联结
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ------ | --------------------------- |
|
||
| `left` | table | Table,左表 |
|
||
| `right` | table | Table,右表 |
|
||
| `ons` | string | String,联结字段，可以为数组 |
|
||
| `how` | string | String,: 联结类型 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
范例1：
|
||
|
||
```tsl
|
||
left := `array('a': 3->5, 'b': rand(3));
|
||
right := `array('a': 1->4, 'b': rand(4), 'c': rand(4) * 10);
|
||
return framemerge(left, right, 'a');
|
||
```
|
||
|
||
范例2
|
||
|
||
```tsl
|
||
// 多字段merge
|
||
left := `array('a': 3->5, 'b': rand(3));
|
||
left[: , 'c'] := left[: , 'a'];
|
||
right := `array('a': 1->4, 'b': rand(4), 'c': rand(4) * 10);
|
||
right[: , 'c'] := right[: , 'a'];
|
||
names := array('a', 'c');
|
||
return framemerge(left, right, name, 'lfet', nil, true);
|
||
```
|
||
|
||
范例3
|
||
|
||
```tsl
|
||
// 只更名right
|
||
left := `array('a': 3->5, 'b': rand(3));
|
||
right := `array('a': 1->4, 'b': rand(4), 'c': rand(4) * 10);
|
||
return framemerge(left, right, 'a', 'full', array(nil, '_x'));
|
||
```
|
||
|
||
## `frameqcut(data, q)`
|
||
|
||
数据表-按频率分组(等频分组)
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | ------- | -------------------------------------------- |
|
||
| `data` | table | Table,数据表或一维数字数组，数据表时，表示对 |
|
||
| `q` | integer | Integer,分组数，等分q组，正整数，默认q=5 |
|
||
|
||
返回：array
|
||
|
||
## `frameupdate(left, right, ons, _type, _type)`
|
||
|
||
数据表-更新
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ------- | -------------------------------------------- |
|
||
| `left` | table | Table,待更新数据，直接更改 |
|
||
| `right` | table | Table,右表 |
|
||
| `ons` | string | String,键字段，默认为nil，表以下标进行联结。 |
|
||
| `_type` | integer | Integer,缺失类型，详见MF_isMissValue |
|
||
| `_type` | integer | 为以下数值的组合(以下数值的\_XOR或者相加) |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
left := `array('a': 3->5, 'b': rand(3));
|
||
right := `array('a': 1->4, 'b': rand(4), 'c': rand(4) * 10);
|
||
return frameupdate(left, right, 'a');
|
||
```
|
||
|
||
## `groupZscoreIt(t, g_name, v_name)`
|
||
|
||
1.计算分组标准化，对数据表t按[GName]分组后，对每组的[Vname_]进行标准化(原值-分组平均)/分组标准差
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
|
||
| `t` | array | 数组，待计算的数组 |
|
||
| `g_name` | string | 字符串，分组字段名 |
|
||
| `v_name` | string | 字符串，转换字段名。如果Vname*为nil则表示除GName之外的所有字段，如果Vname*为一个数组，则表示需要计算的字段组返回:二维数组， |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := array(
|
||
("G": 1, "V1": 1, "V2": 11, "V3": 21),
|
||
("G": 0, "V1": 2, "V2": 12, "V3": 22),
|
||
("G": 1, "V1": 3, "V2": 13, "V3": 23),
|
||
("G": 0, "V1": 4, "V2": 14, "V3": 24),
|
||
("G": 1, "V1": 5, "V2": 15, "V3": 25),
|
||
("G": 0, "V1": 6, "V2": 16, "V3": 26));
|
||
return groupZscoreIt(t, 'G', 'V1');? // array(-1.0,-1.0,0.0,0.0,1.0,1.0)
|
||
```
|
||
|
||
## `framecut(a, bins, option, o_lables)`
|
||
|
||
从小到大分段分组，最小的为第0组
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---------- | ------- | --------------------------------------------------------------------------- |
|
||
| `a` | array | 数据表或一维数字数组，数据表时，表示对每列分别操作 |
|
||
| `bins` | array | 一维数字数组，分段节点，例如array(0,1)将数组a分为[-inf,0)[0,1)[1,inf)三段， |
|
||
| `option` | integer | 整型，区间开/闭，默认为0 |
|
||
| `o_lables` | integer | 数组，输出分组区间说明 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
范例1：
|
||
|
||
```tsl
|
||
a := array(0, 59, 60, 70, 80, 99, 100);
|
||
bins := array(60, 80);
|
||
return framecut(a, bins, 0);
|
||
// array(0,0,1,1,2,2,2)
|
||
```
|
||
|
||
范例2
|
||
|
||
```tsl
|
||
a := array(0, 59, 60, 70, 80, 99, 100);
|
||
bins := 5;
|
||
return framecut(a, bins, 0);
|
||
// array(0,2,3,3,4,4,4)
|
||
```
|
||
|
||
## `frameMelt(t, id_names, value_names, variable_sname, value_sname)`
|
||
|
||
二维表——>立体表
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---------------- | ------ | ------------------------------------------------------------------- |
|
||
| `t` | array | 二维字符串数组，数据表 |
|
||
| `id_names` | array | 一维字符串数组，键字段 |
|
||
| `value_names` | array | 一维字符串数组，值字段。为nil或者空时，表每行除开键字段外都是值字段 |
|
||
| `variable_sname` | string | 字符串，变量展示名 |
|
||
| `value_sname` | string | 字符串，值展示名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t := array(
|
||
('截止日': 20210101, 'SH000300': 1, 'SH000301': 3),
|
||
('截止日': 20210102, 'SH000300': 9, 'SH000301': 2),
|
||
);
|
||
id_names := array('截止日');
|
||
return frameMelt(t, '截止日', nil, '代码', '得分');
|
||
// 输出：
|
||
// 示例包含说明文字，未作为可执行片段运行。
|
||
```
|
||
|
||
## `groupDemeanIt(t, g_name, v_name)`
|
||
|
||
1、分组去均值，对数据表t按[GName]分组后，对每组的[VName]去均值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ------------------------ |
|
||
| `t` | dbdata | 数据表，待分组去均值数据 |
|
||
| `g_name` | string | 字符串，t的分组字段名 |
|
||
| `v_name` | string | 字符串，去均值字段名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
范例1：
|
||
|
||
```tsl
|
||
t := array(
|
||
("G": 1, "V1": 1, "V2": 11, "V3": 21),
|
||
("G": 0, "V1": 2, "V2": 12, "V3": 22),
|
||
("G": 1, "V1": 3, "V2": 13, "V3": 23),
|
||
("G": 0, "V1": 4, "V2": 14, "V3": 24),
|
||
("G": 1, "V1": 5, "V2": 15, "V3": 25),
|
||
("G": 0, "V1": 6, "V2": 16, "V3": 26));
|
||
return groupDemeanIt(t, 'G', 'V1'); // array(-2.0,-2.0,0.0,0.0,2.0,2.0)
|
||
```
|
||
|
||
范例2
|
||
|
||
```tsl
|
||
t := array(
|
||
("G": 1, "V1": 1, "V2": 11, "V3": 21),
|
||
("G": 0, "V1": 2, "V2": 12, "V3": 22),
|
||
("G": 1, "V1": 3, "V2": 13, "V3": 23),
|
||
("G": 0, "V1": 4, "V2": 14, "V3": 24),
|
||
("G": 1, "V1": 5, "V2": 15, "V3": 25),
|
||
("G": 0, "V1": 6, "V2": 16, "V3": 26));
|
||
return groupDemeanIt(t, 'G', array('V1', 'V2'));
|
||
// 输出：
|
||
// Execute script error at Line:8
|
||
// function:__main__:line 8:instruction:array: function:groupDemeanIt compile error or not found
|
||
// function:__main__:line 8:instruction:array: function execute error
|
||
```
|
||
|
||
## `arrDropDuplicate(data)`
|
||
|
||
数组去重(包含NAN)。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | ----- | -------------------- |
|
||
| `data` | array | 数据表类型。数据表。 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
data := array(("A": 1, "B": nan), ("A": 1, "B": 2), ("A": 1, "B": nan), ("A": 1, "B": 2));
|
||
return arrDropDuplicate(data);
|
||
// 结果：array(("A":1,"B":NAN),("A":1,"B":2))
|
||
```
|
||
|
||
## `getSubTableByField(t)`
|
||
|
||
获取表t中的Fields 列的数据。该函数功能可以用子矩阵的方式实现:t[:,array(fn1,fn2...)]
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | ------------------ |
|
||
| `t` | array | 数据表类型，数据表 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
setSysParam(pn_stock(), 'SZ000001');
|
||
r := nDay(10, 'time', dateToStr(sp_time()), 'close', close(), 'open', open(), 'high', high());
|
||
return getSubTableByField(r, 'time;close');
|
||
// 功能相当于使用子矩阵取数
|
||
return r[: , array('time', 'close')];
|
||
// 返回:
|
||
```
|
||
|
||
## `arraygetdefault(r, k, v)`
|
||
|
||
带默认值的数组取值，取指定下标的值，若存在则返回，否则返回设定的默认值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | --------------- | ---------------- |
|
||
| `r` | array of string | Array of string, |
|
||
| `k` | string | String,下标 |
|
||
| `v` | string | String,默认值 |
|
||
|
||
返回：any
|
||
|
||
## `arraysetdefault(r, k, v)`
|
||
|
||
带默认值的数组赋值(字段未使用则赋值)
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | --------------- | ---------------- |
|
||
| `r` | array of string | Array of string, |
|
||
| `k` | string | String,下标 |
|
||
| `v` | string | String,默认值 |
|
||
|
||
返回：bool
|
||
|
||
## `arraysetdefault2(r, k, v)`
|
||
|
||
带默认值的数组赋值(值为nil则赋值)
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | --------------- | ---------------- |
|
||
| `r` | array of string | Array of string, |
|
||
| `k` | string | String,下标 |
|
||
| `v` | string | String,默认值 |
|
||
|
||
返回：bool
|
||
|
||
## `randomchoice(avalues, size, replace)`
|
||
|
||
随机抽样
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------- | --------------- | ---------------------------------------- |
|
||
| `avalues` | array of string | Array of string,一维字符串数组，或正整数 |
|
||
| `size` | integer | Integer, |
|
||
| `replace` | bool | Bool,是否可放回,默认为真可放回 |
|
||
|
||
返回：any
|
||
|
||
## `filterIntersectionPart(t1, t2, f_name, method)`
|
||
|
||
求两个数组在指定列名上的差集、交集、并集
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ----------------------------------------------- |
|
||
| `t1` | array | 数据表 |
|
||
| `t2` | array | 数据表 |
|
||
| `f_name` | string | 指定列名字符串 |
|
||
| `method` | string | 方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(('a': 1, 'b': 10, 'c': 13), ('a': 2, 'b': 17, 'c': 13));
|
||
t2 := array(('a': 2, 'b': 22, 'c': 23), ('a': 1, 'b': 14, 'c': 13), ('a': 3, 'b': 12, 'c': 13));
|
||
return filterIntersectionPart(t1, t2, 'a', 'IN'); // t1 与t2的交集
|
||
// 输出：
|
||
// 示例包含说明文字，未作为可执行片段运行。
|
||
```
|
||
|
||
## `filterIntersectionPart2(t1, t2, method)`
|
||
|
||
求两个数组的差集、交集、并集。只适用一维数组。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ----------------------------------------------- |
|
||
| `t1` | array | 一维数据表 |
|
||
| `t2` | array | 一维数据表 |
|
||
| `method` | string | 方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(1, 2, 3, 4);
|
||
t2 := array(3, 4, 5, 6);
|
||
return filterIntersectionPart2(t1, t2, 'IN'); // t1 与t2的交集
|
||
// 输出：
|
||
// 示例包含说明文字，未作为可执行片段运行。
|
||
```
|
||
|
||
## `averageByColumn(t, f_name)`
|
||
|
||
求指定列的平均值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | -------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
|
||
return averageByColumn(t1, 'b');
|
||
// 结果：6
|
||
```
|
||
|
||
## `harMeanByColumn(t, f_name)`
|
||
|
||
指定列的调和平均值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | -------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
|
||
return harMeanByColumn(t1, 'b');
|
||
// 结果：4.44
|
||
```
|
||
|
||
## `geoMeanByColumn(t, f_name)`
|
||
|
||
指定列的几何平均值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | -------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
|
||
return geoMeanByColumn(t1, 'b');
|
||
// 结果：4.47
|
||
```
|
||
|
||
## `devsqByColumn(t, f_name)`
|
||
|
||
指定列平均值偏差的平方和
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | -------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
|
||
return devsqByColumn(t1, 'b');
|
||
// 结果：0.5
|
||
```
|
||
|
||
## `kurtByColumn(t, f_name)`
|
||
|
||
指定列的峰度
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | -------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return kurtByColumn(t2, 'c');
|
||
// 结果：0.34
|
||
```
|
||
|
||
## `medianByColumn(t, f_name)`
|
||
|
||
指定列的中位数
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ---------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名，字符串 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return medianByColumn(t2, 'c');
|
||
// 结果：38
|
||
```
|
||
|
||
## `skewByColumn(t, f_name)`
|
||
|
||
指定列的偏度
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ---------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名，字符串 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return skewByColumn(t2, 'c');
|
||
// 结果：-0.75
|
||
```
|
||
|
||
## `stdevByColumn(t, f_name)`
|
||
|
||
指定列的标准差
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ---------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名，字符串 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return stdevByColumn(t2, 'c');
|
||
// 结果：17.08
|
||
```
|
||
|
||
## `varByColumn(t, f_name)`
|
||
|
||
指定列的方差
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ---------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名，字符串 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return varByColumn(t2, 'c');
|
||
// 结果：291.67
|
||
```
|
||
|
||
## `aveDevByColumn(t, f_name)`
|
||
|
||
指定列与平均值的绝对偏差的平均值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ------ | ---------------- |
|
||
| `t` | array | 数据表 |
|
||
| `f_name` | string | 指定列名，字符串 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return aveDevByColumn(t2, 'c');
|
||
// 结果：12.5
|
||
```
|
||
|
||
## `percentValueByField(t, key_field, quart)`
|
||
|
||
数据集在指定百分位数上对应的数值
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----------- | ------ | ---------------- |
|
||
| `t` | array | 数据表 |
|
||
| `key_field` | string | 指定列名，字符串 |
|
||
| `quart` | real | 指定分位数，实数 |
|
||
|
||
返回：real
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
|
||
return percentValueByField(t2, 'c', 0.1);
|
||
// 结果：19
|
||
```
|
||
|
||
## `statByColumn(t, fname, _type)`
|
||
|
||
依据Type传递的字符串，返回字段Fname序列的type值。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | ------ | ---------------- |
|
||
| `t` | array | 数据表类型，数据 |
|
||
| `fname` | string | 字符串，字段名称 |
|
||
| `_type` | string | 字符串，返回类型 |
|
||
|
||
返回：any
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
|
||
return statByColumn(s, 'a', 'MAX');
|
||
// 返回a列最大值:5
|
||
```
|
||
|
||
## `describe(data, percentiles)`
|
||
|
||
简单描述统计
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------------- | --------------- | ---------------------------------------------------- |
|
||
| `data` | array of number | 一维数字数组,或 二维矩阵。二维矩阵时，对每列进行操作 |
|
||
| `percentiles` | array of number | 统计的分位点，默认取array(0.25,0.5, 0.75) |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
范例01:
|
||
|
||
```tsl
|
||
load_dataset_iris(data);
|
||
return describe(data);
|
||
```
|
||
|
||
范例02:
|
||
|
||
```tsl
|
||
return describe(randn(0, 1, 1000), array(0.05, 0.1)->0.95);
|
||
```
|
||
|
||
## `framecorrel(data)`
|
||
|
||
数据表-相关系数矩阵
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | ----- | ----------------------------------------------- |
|
||
| `data` | table | Table,二维数据表，列名可为字符串,不支持一维数组 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
data := TSUT_Data_ZSZF()[: , 1:];
|
||
return framecorrel(data);
|
||
```
|
||
|
||
## `framecov(data)`
|
||
|
||
数据表-协方差
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | ----- | ------------------------------------------------ |
|
||
| `data` | table | Table,二维数据表，列名可为字符串。不支持一维数组 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
data := TSUT_Data_ZSZF()[: , 1:];
|
||
return framecov(data);
|
||
```
|
||
|
||
## `framehhi(data)`
|
||
|
||
数据表-HHI指数、赫芬达尔—赫希曼指数
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | ----- | ---------- |
|
||
| `data` | table | Table,数组 |
|
||
|
||
返回：array
|
||
|
||
## `framevaluecounts(data, countfieldname, iforder)`
|
||
|
||
数据表-计数
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---------------- | ------ | ------------------------------------ |
|
||
| `data` | table | Table,可以为二维数据表或者为一维数组 |
|
||
| `countfieldname` | string | String,计数字段名，默认为""个数"" |
|
||
| `iforder` | bool | Bool,是否排序，默认为真 |
|
||
|
||
返回：array
|
||
|
||
## `simpledescribe(data)`
|
||
|
||
简单描述统计
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------ | --------------- | ----------------------------------------------------- |
|
||
| `data` | array of number | 一维数字数组，或 二维矩阵，二维矩阵时，对每列进行操作 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
范例01
|
||
|
||
```tsl
|
||
load_dataset_iris(data);
|
||
return simpledescribe(data);
|
||
```
|
||
|
||
范例02
|
||
|
||
```tsl
|
||
return simpledescribe(randn(0, 1, 1000), array(0.05, 0.1)->0.95);
|
||
```
|
||
|
||
## `renameFieldByFormat(t, ifcopy)`
|
||
|
||
通过格式字符串修改列名。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------- | ----- | -------------------------------------------- |
|
||
| `t` | array | 数组类型，数据 |
|
||
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 给随机数组批量加后缀
|
||
t := rand(10, 10);
|
||
suffix := '%s'$"@A";
|
||
ifcopy := true;
|
||
return renameFieldByFormat(t, suffix, ifcopy);
|
||
// 输出：
|
||
// Execute script error at Line:5
|
||
// function:__main__:line 5:instruction:usercall: function:renameFieldByFormat compile error or not found
|
||
// function:__main__:line 5:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sparse1(s, a, m, n)`
|
||
|
||
挤出任何非零元素，将满矩阵转化为稀疏格式，与Sparsefull函数对应。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | --------------------------------- |
|
||
| `s` | array of real | 待转化的m\*n满矩阵 |
|
||
| `a` | array of real | 变参返回矩阵S的稀疏格式，二维数组 |
|
||
| `m` | integer | 变参返回矩阵S的行数，整数 |
|
||
| `n` | integer | 变参返回矩阵S的列数，整数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 将矩阵S由满矩阵格式转化为稀疏格式
|
||
s := array((0, 0, 4, 0, 0),
|
||
(0, 1, 0, 0, 0),
|
||
(0, 0, 0, 0, 0),
|
||
(3, 0, 0, 0, 0),
|
||
(0, 0, 0, 0, 5));
|
||
return sparse1(s);
|
||
// 输出：
|
||
// Execute script error at Line:7
|
||
// function:__main__:line 7:instruction:usercall: function:sparse1 compile error or not found
|
||
// function:__main__:line 7:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sparse2(i, j, v, m, n)`
|
||
|
||
根据i、j和v三元组生成m\*n稀疏格式矩阵S
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | ------------------------ |
|
||
| `i` | array of real | 存放矩阵行标的一元数组 |
|
||
| `j` | array of real | 存放矩阵列标的一元数组 |
|
||
| `v` | array of real | 存放矩阵元素值的一元数组 |
|
||
| `m` | integer | 矩阵的行数，整数 |
|
||
| `n` | integer | 矩阵的列数，整数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 根据i,j,v三元组生成稀疏格式矩阵
|
||
i := array(0, 1, 2, 3);
|
||
j := array(3, 1, 4, 2);
|
||
v := array(5, 3, 2, 4);
|
||
return sparse2(i, j, v, 5, 5);
|
||
// 输出：
|
||
// Execute script error at Line:5
|
||
// function:__main__:line 5:instruction:usercall: function:sparse2 compile error or not found
|
||
// function:__main__:line 5:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `speye(m)`
|
||
|
||
创建m\*m稀疏单位矩阵，指定为方阵
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------- | ------------------------ |
|
||
| `m` | integer | 稀疏单位矩阵的尺寸，整数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建m*m稀疏单位矩阵
|
||
a := speye(4);
|
||
return a;
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:speye compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sprand1(s)`
|
||
|
||
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | -------- |
|
||
| `s` | array of real | 稀疏矩阵 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建与矩阵S相同结构的稀疏均匀随机矩阵
|
||
s := array((0, 0, 3, 0, 0),
|
||
(0, 0, 0, 0, 0),
|
||
(0, 0, 0, 5, 0),
|
||
(0, 2, 0, 0, 0),
|
||
(0, 0, 0, 0, 4));
|
||
return sprand1(s);
|
||
// 输出：
|
||
// Execute script error at Line:7
|
||
// function:__main__:line 7:instruction:usercall: function:sprand1 compile error or not found
|
||
// function:__main__:line 7:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sprand2(m, n, pct)`
|
||
|
||
创建m\*n稀疏均匀随机矩阵，其中非零元素所占比例为pct
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ------- | ---------------------------- |
|
||
| `m` | integer | 矩阵的行数，整数 |
|
||
| `n` | integer | 矩阵的列数，整数 |
|
||
| `pct` | real | 矩阵中非零元素所占比例，实数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建10*10稀疏均匀随机矩阵
|
||
a := sprand2(10, 10, 0.3);
|
||
return a;
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:sprand2 compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sprandn1(s)`
|
||
|
||
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | -------- |
|
||
| `s` | array of real | 稀疏矩阵 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建与矩阵S相同结构的稀疏正态随机矩阵
|
||
s := array((0, 0, 0, 0, 0),
|
||
(0, 0, 0, 5, 0),
|
||
(3, 0, 0, 0, 0),
|
||
(0, 0, 2, 0, 0),
|
||
(0, 0, 0, 0, 4));
|
||
return sprandn1(s);
|
||
// 输出：
|
||
// Execute script error at Line:7
|
||
// function:__main__:line 7:instruction:usercall: function:sprandn1 compile error or not found
|
||
// function:__main__:line 7:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sprandn2(m, n, pct)`
|
||
|
||
创建m\*n稀疏正态随机矩阵，其中非零元素所占比例为pct
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ------- | ---------------------------- |
|
||
| `m` | integer | 矩阵的行数，整数 |
|
||
| `n` | integer | 矩阵的列数，整数 |
|
||
| `pct` | real | 矩阵中非零元素所占比例，实数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建10*10稀疏正态随机矩阵
|
||
a := sprandn2(10, 10, 0.2);
|
||
return a;
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:sprandn2 compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sprandsym1(s)`
|
||
|
||
创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | -------- |
|
||
| `s` | array of real | 稀疏矩阵 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建与矩阵S相同结构的对称稀疏正态随机矩阵
|
||
s := array((6, 1, 0, 14, 0),
|
||
(0, 7, 0, 0, 15),
|
||
(1, 0, 8, 0, 0),
|
||
(0, 2, 0, 9, 0),
|
||
(0, 0, 3, 0, 10));
|
||
return sprandsym1(s);
|
||
// 输出：
|
||
// Execute script error at Line:7
|
||
// function:__main__:line 7:instruction:usercall: function:sprandsym1 compile error or not found
|
||
// function:__main__:line 7:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sprandsym2(n, pct)`
|
||
|
||
创建n\*n稀疏正态随机矩阵，以下三角矩阵为基准对称正态分布随机矩阵，其中非零元素所占比例大约为pct
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----- | ------- | ---------------------------- |
|
||
| `n` | integer | 方阵的尺寸，整数 |
|
||
| `pct` | real | 方阵中非零元素所占比例，实数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 创建10*10对称稀疏正态随机矩阵
|
||
a := sprandnsym2(10, 0.2);
|
||
return a;
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:sprandnsym2 compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `sparsefull(s, m, n)`
|
||
|
||
将稀疏矩阵格式转化为满矩阵，与Sparse1函数相对应。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | ------------------------ |
|
||
| `s` | array of real | 稀疏格式矩阵 |
|
||
| `m` | integer | 转化为满矩阵的行数，整数 |
|
||
| `n` | integer | 转化为满矩阵的列数，整数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 将S由稀疏格式矩阵转化为5*5满矩阵格式
|
||
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
|
||
return sparsefull(s, 5, 5);
|
||
// 输出：
|
||
// Execute script error at Line:3
|
||
// function:__main__:line 3:instruction:usercall: function:sparsefull compile error or not found
|
||
// function:__main__:line 3:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `spones(s, n)`
|
||
|
||
将稀疏矩阵S中的非零元素替换为n
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | ------------------------ |
|
||
| `s` | array of real | 稀疏矩阵 |
|
||
| `n` | real | 非零元素被替换的值，实数 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 将S中非零元素替换为1
|
||
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
|
||
return spones(s, 1);
|
||
// 输出：
|
||
// Execute script error at Line:3
|
||
// function:__main__:line 3:instruction:usercall: function:spones compile error or not found
|
||
// function:__main__:line 3:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `spnnz(s)`
|
||
|
||
稀疏矩阵S中的非零元素数目
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | -------- |
|
||
| `s` | array of real | 稀疏矩阵 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 稀疏正态随机矩阵A中非零元素数目
|
||
a := sprandn2(5, 5, 0.2);
|
||
return spnnz(a); // 返回4（随机）
|
||
```
|
||
|
||
## `spnonzeros(s)`
|
||
|
||
提取稀疏矩阵S中的非零元素
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | -------- |
|
||
| `s` | array of real | 稀疏矩阵 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 提取稀疏正态随机矩阵A中非零元素
|
||
a := sprandn2(5, 5, 0.2);
|
||
return spnonzeros(a);
|
||
// 输出：
|
||
// Execute script error at Line:2
|
||
// function:__main__:line 2:instruction:usercall: function:sprandn2 compile error or not found
|
||
// function:__main__:line 2:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `ifsparse(s)`
|
||
|
||
判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------------- | ---------- |
|
||
| `s` | array of real | 待判断矩阵 |
|
||
|
||
返回：integer
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 判断矩阵S是否为稀疏矩阵
|
||
s := Array(3: 2, "B": 3);
|
||
return ifsparse(s); // 返回0
|
||
```
|
||
|
||
## `spdiags1(a)`
|
||
|
||
提取矩阵非零对角线
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | ------------------------------ |
|
||
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 提取矩阵A中非零对角线
|
||
a := array((6, 0, 13, 0, 0),
|
||
(0, 7, 0, 14, 0),
|
||
(1, 0, 8, 0, 15),
|
||
(0, 2, 0, 9, 0),
|
||
(0, 0, 3, 0, 10));
|
||
return spdiags1(a);
|
||
```
|
||
|
||
## `spdiags2(a, d)`
|
||
|
||
提取矩阵指定对角线
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | ------------------------------------------ |
|
||
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
|
||
| `d` | array | Array,一维数组，对角线序列；也可以为数字； |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 提取矩阵A中第-2,0,2条对角线，按列排列
|
||
a := array((6, 0, 13, 0, 0),
|
||
(0, 7, 0, 14, 0),
|
||
(1, 0, 8, 0, 15),
|
||
(0, 2, 0, 9, 0),
|
||
(0, 0, 3, 0, 10));
|
||
d := array(-2, 0, 2);
|
||
return spdiags2(a, d);
|
||
```
|
||
|
||
## `spdiags3(b, d, a)`
|
||
|
||
根据指定列替换稀疏矩阵对角线
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ----- | ------------------------------ |
|
||
| `b` | array | Array,二维数组，对角矩阵 |
|
||
| `d` | array | Array,一维数组，对角线序列 |
|
||
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 将矩阵A中d指定的对角线替换为B中的列
|
||
b := array((5, 10, 15),
|
||
(4, 9, 14),
|
||
(3, 8, 13),
|
||
(2, 7, 12),
|
||
(1, 6, 11));
|
||
d := array(-2, 0, 2);
|
||
a := array((6, 0, 13, 0, 0),
|
||
(0, 7, 0, 14, 0),
|
||
(1, 0, 8, 0, 15),
|
||
(0, 2, 0, 9, 0),
|
||
(0, 0, 3, 0, 10));
|
||
return spdiags3(b, d, a);
|
||
```
|
||
|
||
## `spdiags4(b, d, m, n)`
|
||
|
||
根据指定列创建稀疏矩阵
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ---- | ------- | -------------------------------- |
|
||
| `b` | array | Array,二维数组，对角矩阵 |
|
||
| `d` | array | Array,一维数组，对角线序列 |
|
||
| `m` | integer | Integer,正整数，（稀疏）矩阵的行 |
|
||
| `n` | integer | Integer,正整数，（稀疏）矩阵的列 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 根据对角矩阵B创建稀疏带状矩阵
|
||
b := array((5, 10, 15),
|
||
(4, 9, 14),
|
||
(3, 8, 13),
|
||
(2, 7, 12),
|
||
(1, 6, 11));
|
||
d := array(-2, 0, 2);
|
||
m := 5;
|
||
n := 5;
|
||
return spdiags4(b, d, m, n);
|
||
```
|
||
|
||
## `compareDataOfDifferentDataProvider(t_src, t_dest, src_provider, dest_provider, key_arr, value_arr, code_field)`
|
||
|
||
比较两个数据源的差异
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------------- | ------ | ------------------------------------------------------ |
|
||
| `t_src` | array | Array 源数据 |
|
||
| `t_dest` | array | Array 目标数据 |
|
||
| `src_provider` | string | String 源数据提供商 |
|
||
| `dest_provider` | string | String 目标数据提供商 |
|
||
| `key_arr` | array | Array 要比较表的Key字段（也就是数据表中的 唯一性字段） |
|
||
| `value_arr` | array | Array 要比较的Value字段 |
|
||
| `code_field` | string | String 代码字段（任何数据，都必须有编码字段） |
|
||
|
||
返回：array
|
||
|
||
## `pivot(t, index, vals)`
|
||
|
||
透视，数据透视表
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ------- | --------------- | ------------------------------------------------------------------------------------------------------- |
|
||
| `t` | array | 二维数组，待透视表，t[:,array(index,columns)] 不能包含重复的行，即index，column 必须可以作为t的唯一主键 |
|
||
| `index` | string \| array | 字符串或一维字符串数组，行分类字段，t的列名，多个字段可以用数组，为nil表示取t的行下标 |
|
||
| `vals` | string \| array | 字符串或一维字符串数组，值字段，t的列名，多个字段可以用数组， |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 指定条件，行标为日期，列标为名称，值为收盘价、涨幅、振幅的数据透视表
|
||
stocks := array("SZ000001", "SZ000002", "SH600050", "SZ300775");
|
||
begt := 20210515T;
|
||
endt := 20210525T;
|
||
t := select ['StockID'] as "代码",
|
||
["StockName"] as "名称",
|
||
dateToStr(['date']) as "日期",
|
||
["close"] as "收盘价",
|
||
spec(specDate(stockZf3(), ['date']), ['StockID']) as "涨幅",
|
||
spec(specDate(stockZdf3(), ['date']), ['StockID']) as "振幅",
|
||
spec(base(10029), ['StockID']) as "申万行业"
|
||
from markettable datekey begt to endt of stocks end;
|
||
index := "日期";
|
||
colunms := "名称";
|
||
vals := array("收盘价", "涨幅", "振幅");
|
||
return pivot(t, index, colunms, vals);
|
||
// 输出：
|
||
// Execute script error at Line:16
|
||
// function:__main__:line 16:instruction:usercall: function:pivot compile error or not found
|
||
// function:__main__:line 16:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `nonIntersectionPart(t1, t2, key_field)`
|
||
|
||
求差集(返回在t1中存在，而在t2中不存在的记录)
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----------- | ------ | ------------ |
|
||
| `t1` | array | 数据表 |
|
||
| `t2` | array | 数据表 |
|
||
| `key_field` | string | 指定某一字段 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
|
||
t2 := array(('a': 1, 'b': 1), ('a': 7, 'b': 8), ('a': 5, 'b': 5));
|
||
return nonIntersectionPart(t1, t2, 'b');
|
||
// 输出：
|
||
// Execute script error at Line:3
|
||
// function:__main__:line 3:instruction:usercall: function:nonIntersectionPart compile error or not found
|
||
// function:__main__:line 3:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `getSubTableByKey(t, key_field, return_fields)`
|
||
|
||
将字符串KeyField以分号分隔,在数组t中从列ReturnFields匹配被分割的值,若找到则返回该行信息，否则返回空数组。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| --------------- | ------ | ------------------------ |
|
||
| `t` | array | 数据表类型，数据表 |
|
||
| `key_field` | string | 字符串，关键字字段 |
|
||
| `return_fields` | string | 字符串，要返回的字段名称 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
|
||
array('A': 'c', 'B': 3, 'C': 4, 'D': 5, 'e': 6),
|
||
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7));
|
||
return getSubTableByKey(s, 'A', 'a;c');
|
||
// 返回:
|
||
```
|
||
|
||
## `expandTable(t, key_field)`
|
||
|
||
按指定字段展开表格，根据Keyfield展开指定列。展开的列值必须二维数据表，否则保留原值。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| ----------- | ------ | -------------------------------- |
|
||
| `t` | array | 数组类型，数据 |
|
||
| `key_field` | string | 字符串类型，关键字，需展开的列名 |
|
||
|
||
返回：array
|
||
|
||
### 示例
|
||
|
||
```tsl
|
||
// 按照分红送股列展开数据
|
||
data := query("", "SH600000;SZ000002", true, "", "代码", defaultStockId(), "名称",
|
||
currentStockName(), "分红送股", infoArray(18));
|
||
return expandTable(data, "分红送股");
|
||
// 输出：
|
||
// Execute script error at Line:4
|
||
// function:__main__:line 4:instruction:usercall: function:expandTable compile error or not found
|
||
// function:__main__:line 4:instruction:usercall: function execute error
|
||
```
|
||
|
||
## `arrayToFm(value, sample_value)`
|
||
|
||
将数组转换为 FMArray，并按样例值确定单元格类型。
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
| -------------- | ----- | ----------------------------------------------------------- |
|
||
| `value` | array | 输入数组 |
|
||
| `sample_value` | float | 单元格类型样例；如 `0` 生成整型单元格，`0.0` 生成浮点单元格 |
|
||
|
||
返回：fmarray
|