197 KiB

Raw Blame History

06 扩展语法（矩阵/集合/结果集过滤/TS-SQL）

本章覆盖集合运算、结果集过滤、矩阵计算与 TS-SQL 相关语法。

集合运算

集合运算简介

在 TSL 语言中，和大多数的语言不同，省略了集合这种独立的数据类型，在各种语言中，集合的实现有些差异，在元素不多的时候，许多采用整数来描述集合，用对位的设置来描述集合中的元素存在与否。事实上，在矩阵计算以及以行为单位的运算中(TS-SQL)，传统语言的集合概念不是很吻合具体的应用。

TSL 语言中，以数组（矩阵）作为集合运算的基础，而数组也可以理解为包含其元素的结合，和数学意义上的集合不同，TSL 中的数组允许同时具有不同数据类型的数据，例如同时具有数字和字符串，因此 TSL 的集合运算中的元素也是同时允许多种数据类型的。

集合运算有一个特征，由于在数学意义上集合的元素是不允许重复的，而在数组中的元素是允许重复的，在集合运算中，结果集均为已去除重复项的结果。

IN 存在判断符

用户经常会有这个的需求，即某个数字或者字符串是否出现在数组中，另外，用户也可能会需要知道，数组中的所有的元素是否均存在于另外一个数组中，这样的关系对于集合而言，一个称之为属于，另一个称之为包含，在 TSL 中，使用 IN 操作符同时支持属于和包含的关系。

语法：V IN R

含义：V 是否存在于 R 结果集中或者 V 是否是 R 的子集，V 即可是元素，也可以是集合。

返回值：布尔类型，真假

注：In 是以最小的元素进行判断。

例如 1 in array(1,2,2)为真，1 in array(0,2)为假，需要注意的是，in 操作符号允许后边的结果集为多维数组，例如 1 in array((1),(2))同样会返回为真。

in 操作符同样支持子集判断，

例如 array(1,2) in array(1,2,3,4)为真，

array(1,3) in array((1,2),(3,4))为真

array(1,2) in array(1)为假。

2025/8 月版本支持 Not IN，这样 not(a in b)可以简单写成 a not in b

基于行的集合运算

传统数学意义上的集合运算是以元素为单位的，由于实际应用中处理结果集经常需要使用到以行为单位的集合运算，所以 TSL 中的集合运算符号大多支持的是以行为单位。

SQLIn 运算符

集合 SQLIN 的判断，和 IN 不同，是以行的模式来判定是否在其中，左边一定是右边的元素才返回真。

语法：V SQLIn R

含义：V 这一条记录是否存在于表 R 中，V 为一条记录。

注：SQLIn 是以行为单位进行判断。

例如：

1 SQLIn array(1,2)为真

Array(1,2) SQLIn array(1,2,3)为假

Array(1,2) SQLIn array((1,2),(3,4))为真

2025/8 月版本支持 Not sqlin，这样 not(a sqlin b)可以简单写成 a not sqlin b

sqlIn 与 In 的差异表现可参考：Q：数组存在于的判断：SQLIN 与 IN 在集合运算中的应用

Union2 并集算符

集合的并集运算是将两个集合中的元素的合集去重后的结果。和 IN 运算不同，TSL 在处理并集的时候的时候元素是以行为单位的，而不是以单元格为单位。

因此，集合的并集是行的并集，而不是元素的并集，所以 Union2 是去除重复行的行的合集。

语法：A Union2 B

含义：求 A 和 B 的并集

返回值：去掉重复项的并集。

例如：

结果集 A 内容为：

1 2 3 4

2 3 4 5

1 1 1 1

结果集 B 内容为：

1 2 3 4

3 4 5 6

2 2 2 2

A UNION2 B 的结果为：

1 2 3 4

2 3 4 5

1 1 1 1

3 4 5 6

2 2 2 2

Intersect 交集运算算符

集合的交集运算与并集运算类似也是以行为单位的，而不是以单元格为单位。

因此，集合的交集是行的交集，而不是元素的交集，所以 Intersect 是重复行集。

语法：A Intersect B

含义：求 A 和 B 的交集

返回值：交集。

例如：

结果集 A 内容为：

1 2 3 4

2 3 4 5

1 1 1 1

结果集 B 内容为：

1 2 3 4

3 4 5 6

2 2 2 2

A Intersect B 的结果为：

1 2 3 4

Minus 差集运算符

集合的差集运算与并集运算类似也是以行为单位的，而不是以单元格为单位。

因此，集合的差集是行的差集，而不是元素的差集，所以 Minus 是减去重复行的集。

语法：A Minus B

含义：求 A 和 B 的差集

返回值：差集。

例如：

结果集 A 内容为：

1 2 3 4

2 3 4 5

1 1 1 1

结果集 B 内容为：

1 2 3 4

3 4 5 6

2 2 2 2

A Minus B 的结果为：

2 3 4 5

1 1 1 1

Outersect 对称差集运算符

集合的对称差集运算与并集运算类似也是以行为单位的，而不是以单元格为单位。

因此，集合的对称差集是行的对称差集，而不是元素的对称差集，所以 Outersect 是减去重复行的并集。

Outersect 比较特殊，在其他语言很少提供这类功能，但是在许多应用中会应用到，A Outersect B 相当于(A Union2 B) Minus (A Intersect B)，也相当于(A Minus B) Union2 (B Minus A)。

语法：A Outersect B

含义：求 A 和 B 的并集去交集

返回值：对称差集。

例如：

结果集 A 内容为：

1 2 3 4

2 3 4 5

1 1 1 1

结果集 B 内容为：

1 2 3 4

3 4 5 6

2 2 2 2

A Outersect B 的结果为：

2 3 4 5

1 1 1 1

3 4 5 6

2 2 2 2

基于元素的集合运算的实现

如果用户的结果集本身是一个一维数组，那么以行为单位的集合运算的结果本身就是以元素为单位的集合运算。

对于二维矩阵而言，怎么做到以元素为单位的集合运算呢？其实很简单，我们只要把二维的矩阵转换成为一维数组再利用集合运算符进行集合运算即可。

将二维数组转换为一维数组的方法最简单的是利用 sselect 语法，关于 SSelect 的使用见 ts-sql 专题。

// 假定我们有一个二维矩阵，我们用 R1:=sselect \* from R
end;就可以把 R 转换为一个一维数组到结果集 R1 了。然后我们的运算可以基于转换后的结果集。

结果集过滤运算

结果集过滤运算简介

过滤集运算是过滤掉二维结果集中某列的内容存在或者不存在于某个一维结果集中的运算，返回的结果可以是过滤后的二维结果集，也可以是二维结果集的下标列表，事实上，结果集过滤完全可以利用 TS-SQL 的 Select 来实现，但是相对于 Select 而言，结果集过滤的效率会更高效也更容易理解。

过滤集运算也可以对二维结果集的整行内容进行过滤，这样的操作非常类似于集合运算，过滤在过滤集内的类似于交集，而反之类似于减集。但是过滤运算和集合运算的最大差异是：集合运算的结果内容不允许有重复项，而过滤运算的结果允许有重复项，也就是说于被过滤集中的重复项目是不会被自动去重的。

结果集过滤关键字定义

TSL 语言种结果集过滤使用两个关键字 FilterIn 和 FilterNotIn 来实现其功能。

结果集过滤范例

在实际应用需求中，用户经常有这样的需求：

假定结果集 R 的下标"Code"列里存贮了代码，我们还有一个代码数组 CodeArr，有时候，我们希望得到 R 的结果集内所有 Code 列包含在代码数组 CodeArr 中的子集，有时候希望得到 R 的结果集内所有 Code 列不包含在代码数组 CodeArr 中的子集。读起来似乎有点拗口，但是相信大家很清楚我们描述的是什么。

假定 R 的内容为

Code V1 V2

0001 8.9 12

0002 9 10

0003 8 8

0004 1 2

假定 CodeArr 的内容为一维数组 array("0001","0003")

FilterIn 取包含的子集

R1 := FilterIn (R, CodeArr, "Code")

结果集 R1 为

Code V1 V2

0001 8.9 12

0003 8 8

FilterNotIn 取不包含的子集

R1 := FilterNotIn (R, CodeArr, "Code")

结果集 R2 为

Code V1 V2

0002 9 10

0004 1 2

返回结果集过滤的行标

上面我们的应用可以返回子结果集，但是往往用户有时需要的只要结果集的行标就可以了，因为我们可能会继续使用返回的行标，例如利用这个行标处理其他结果集。

FilterIn 以及 FilterNotIn 均支持返回下标的功能。

上述的范例中，如果我们使用 FilterIn(R,CodeArr,"Code",false)，返回的结果就只有下标了，结果为 array(0,2),代表下标 0 和下标 2 符合过滤条件，而使用 FilterNotIn(R,CodeArr,"Code",false)的结果则为 array(1,3)。

从上边的范例我们知道 FilterIn/FilterNotIn 的定义为：

FilterIn/FilterNotIn(R,FilterArray,Field,bReturnSubResult)

其中参数对应的含义为：结果集，过滤值数组，列标，是否返回子结果集；最后一个参数可以省略，缺省为真。

不是题外的题外话，过滤后取子结果集：

TSL 的子矩阵功能可以直接利用 FilterIn/FilterNotIn 返回的行标数组来获取子矩阵。

R[array(1,3)]的结果就是 R 的行标为 1 和 3 的子结果集，假使用户只需要取 V1 列，那么用户使用 R[array(1,3),"V1"]可以返回 V1 列的结果集（类型为一维的数组）。

在实际使用中，用户可能需要的是，如果用户要返回的是二维的多列结果集，例如，用户希望返回符合条件的某些特定列，我们怎么做呢？

这很像是一个 SELECT 的操作，我们假定 R 的列还有 V3，V4，V5...列，我们希望取出符合结果的 Code,V1,V2 列：

SubIndex := FilterIn(R, CodeArr, "Code", false);
SubResult := R[SubIndex, array("Code", "V1", "V2")];

对一维数组或者二维数组的行进行结果集过滤的方法

上一个内容是针对二维数组的列来过滤的，如果我们需要过滤整行呢？或者我们的需要过滤的结果集没有列（一维数组），我们如何进行过滤呢？

带着这个问题，我们需要先回顾下我们之前所学到的知识，事实上，我们这个问题是否非常类似于集合运算呢？以行为单位只要过滤子集中出现的内容，是否就是集合运算的交集呢？以行为单位去除掉过滤子集中出现的内容，是否就是集合运算的减集呢？

是的，在许多情况下，这种需求集合运算更为直观和合理，但是并不完全。因为集合运算的结果集表示

例如一维数组里的内容在另一个一维数组里边的和不在其中的，这类需求其实可以转化成为一个集合运算，在其中的则为交集，不在其中的为减集，但需要注意的是集合运算不可重复，而过滤运算则允许重复。

处理二维数组的行过滤以及处理一维数组，其关键则是将 Field 参数设置为 NIL。

例如：array(1,2,3,4,5,5,6,7),过滤留下不在 array(1,2,3,4)其中的结果

FilterNotIn(array(1,2,3,4,5,5,6,7),array(1,2,3,4),nil)，其结果为 array(5,5,6,7)

再如，结果集 R，有字段 A B C：

A B C

1 2 3

2 3 4

1 2 3

4 5 6

结果集 R1 有字段 A B C:

A B C

1 2 3

2 3 4

我们要过滤掉保留 R 中存在于 R1 的：

FilterIn(R,R1,nil)，其结果为：

A B C

1 2 3

2 3 4

1 2 3

对二维数组指定字段列表进行结果集过滤的方法

对于一个二维的结构，如果我们希望过滤的不是一整行，也不是单一列，而是某几列，我们可以将 Field 参数设置为包含字段列表的数组。

例如:

结果集 R，有字段 A B C：

A B C

1 2 3

2 3 4

1 2 5

4 5 6

结果集 R1 有字段 A B:

A B

1 2

2 3

我们要过滤掉保留 R 中字段 A,B 存在于 R1 的：

FilterIn(R,R1,array("A","B"))，其结果为：

A B C

1 2 3

2 3 4

1 2 5

矩阵计算

矩阵计算简介

本节点主要介绍矩阵计算，包括以下内容：

所讲述的矩阵计算是广义的矩阵计算，包括狭义的矩阵计算方法，如：矩阵乘法、矩阵求逆，矩阵除法，矩阵左除，矩阵乘方等等操作，除此以外，矩阵转置、矩阵右并、矩阵下并、矩阵初始化、矩阵循环、矩阵循环赋值、矩阵查找、矩阵大小、子矩阵操作、以及有关数组的基础运算我们也将其作为广义的矩阵计算而纳入本章节，但大多数矩阵相关的函数则不会出现在这个章节，例如矩阵分解，特征根等，那些可以在 TSL 的函数大全中找到相应的内容。

矩阵初始化

TSL 的矩阵支持多维矩阵。

矩阵初始化系统内置支持如下：

Zeros 初始化 0 矩阵，

ones 初始化 1 矩阵，

eye 初始化单位矩阵，

rand 初始化随机矩阵，

Nils 初始化空矩阵,->初始化一个序列。

除了 eye 以外，其他的几个初始化在带一个参数的时候为初始化一个二维数组，带两个参数则初始化一个二维数组（矩阵）。带 N 个参数则为 N 维矩阵(rand 例外，如有第三个参数其恒定为随机产生的方法)。

例如：

Zeros(10)返回的是一个 10 个元素的 0 数组。

Zeros(10,10)返回的是一个 10*10 的全零二维数组。

Eye(10)和 Eye(10,10)的结果一样，都是返回一个 10*10 的单位矩阵。

初始化也可以初始化字符串下标的数组（数据表类型）

例如：

Zeros(10,array("F1","F2"))返回的是一个 10 行两列，列名为 F1 和 F2 的全 0 数组。

而 Zeros(array("L1","L2"),array("F1","F2"))则返回一个以 L1 和 L2 名的下标，F1,F2 为列名的全零矩阵。

具体函数定义参考矩阵初始化运算相关的保留字和算符

矩阵初始化运算相关的保留字和算符

Zeros

范例

t1 := zeros(10); // 返回一个数值全是0的10行的一维数组
t2 := zeros(5, 3); // 返回一个数值全是0的5行3列的自然下标二维数组
t3 := zeros(5, array("A", "B")); // 返回一个数值全是0的5行2列的列名分别为"A","B"的二维数组
t4 := zeros(2, 5, 3); // 返回一个数值全是0的2*5*3的自然下标三维数组

Ones

范例

t1 := ones(10); // 返回一个数值全是1的10行的一维数组
t2 := ones(5, 3); // 返回一个数值全是1的5行3列的自然下标二维数组
t3 := ones(5, array("A", "B")); // 返回一个数值全是1的5行2列的列名分别为"A","B"的二维数组
t4 := ones(2, 5, 3); // 返回一个数值全是1的2*5*3的自然下标三维数组

Rand

范例

范例 01：

// 生成0-1,10*10的随机矩阵，
SetSysParam(PN_Precision(), 4);
return rand(10, 10);

范例 02：

// 生成3*3,矩阵内的元素服从标准正态分布的矩阵
SetSysParam(PN_Precision(), 4);
return rand(3, 3, array("normal", 0, 1));

范例 03：

// 生成3*3*3,矩阵内的元素服从标准正态分布的矩阵
SetSysParam(PN_Precision(), 4);
return rand(3, 3, array("normal", 0, 1), 3);

Nils

范例

t1 := nils(10); // 返回一个数值全是nil的10行的一维数组
t2 := nils(5, 3); // 返回一个数值全是nil的5行3列的自然下标二维数组
t3 := nils(5, array("A", "B")); // 返回一个数值全是nil的5行2列的列名分别为"A","B"的二维数组
t4 := nils(2, 5, 3); // 返回一个数值全是nil的2*5*3的自然下标三维数组

Eye

范例

t1 := eye(10); // 返回10*10的单位矩阵
t2 := eye(5, 3); // 返回5*3的单位矩阵
t3 := eye(5, array("A", "B")); // 返回5行2列的列名分别为"A","B"的单位矩阵

->数列数组初始化算符

定义一：BegValue->EndValue

说明：生成一个从 BegValue 值开始到不大于 EndValue 的以 1 递增的数列

举例：

1->3 的结果为 array(1,2,3)

1.5->5 的结果为 array(1.5,2.5,3.5,4.5)

定义二：array(BegValue,StepValue)->EndValue

说明：生成一个从 BegValue 值开始到不大于 EndValue 的以 StepValue 递增的数列。

举例：

a := array(2.5, 0.5);
B := a -  > 5;

B 的结果为 array(2.5,3,3.5,4,4.5,5)

定义三：array(BegValue,StepValue,IndexArray)->EndValue

说明：生成一个从 BegValue 值开始到不大于 EndValue 的以 StepValue 递增的以 IndexArray 为下标数列。

举例：

a := array(0, 1, array("A", "B", "C", "D", "E", "F"));
B := a -  > 5;

B 的结果为 array("A":0,"B":1,"C":2,"D":3,"E":4,"F":5)

获得矩阵的大小

利用 MSize,MRows,MCols 可以很方便地获得矩阵的大小以及行列等相关信息。

例如：

// A为一个三行两列的随机数组
A := Rand(3, array("F1", "F2"));
B := MSize(A, 0); // B的内容为array(3,2)表示三行两列
C := MSize(A, 1); // C的内容为array((0,1,2),("F1","F2"))

也就是说 MSize 可以获得行列数，也可以获得行列下标的具体值。

如果只要获得行数或者列数或者行下标、列下标

可以利用 mRows 和 mCols

例如：

A := Rand(3, array("F1", "F2"));
B := MRows(A, 0); // B的内容为3
C := MCols(A, 1); // C的内容为2
D := MRows(A, 1); // D的内容为array(0,1,2)
E := MCols(A, 1); // E的内容为Array("F1","F2")

与 MSize 类似的，MRows 和 MCols 既可以返回行数列数，也可以返回行下标或者列下标

相关计算可以参照矩阵大小运算相关的保留字

矩阵大小运算相关的保留字

MSize

范例

返回数组 t 的所有行列长度

t := array(("A":1, "B":2), ("A":11, "B":22), ("A":21, "B":32));
return msize(t);

返回结果：array(3,2)

返回数组 t 的所有行列下标

t := array(("A":1, "B":2), ("A":11, "B":22), ("A":21, "B":32));
return msize(t, 1);

返回结果：array((0,1,2),("A","B"))

MRows

范例

返回数组 t 的行数

t := array(("A":1, "B":2), ("A":11, "B":22), ("A":21, "B":32));
return mrows(t);

返回结果：3

返回数组 t 的所有行列下标

t := array(("A":1, "B":2), ("A":11, "B":22), ("A":21, "B":32));
return mrows(t, 1);

返回结果：array(0,1,2)

MCols

范例

返回数组 t 的列数

t := array(("A":1, "B":2), ("A":11, "B":22), ("A":21, "B":32));
return mcols(t);

返回结果：2

返回数组 t 的所有列下标

t := array(("A":1, "B":2), ("A":11, "B":22));
return mcols(t, 1);

返回结果：array("A","B")

矩阵查找和遍历的保留字和算符

矩阵的查找和遍历是对应于矩阵的每一个单元格的，这样可以将以往需要使用 FOR 循环语句的代码极大地便捷化。

在其他的矩阵计算语言中，同样有类似的功能，但是 TSL 的矩阵查找和遍历的能力更强大，因为其他的矩阵计算语言中，仅仅只能处理单元格的值，而 TSL 还可以利用 MCol,MRow,MIndex,MCell 关键字实现复杂的计算功能。这种功能是 TSL 所独有的特色。

MFind

范例

范例 01：一个参数：返回二维数组的项为真的对应的下标

t := array((0, 2, 3), (2, 3, nil));
return Mfind(t);

范例 02：一个参数：返回一维数组的项为真的对应的下标

t := array(0, 1, 2, 3, nil, 4);
return Mfind(t);

范例 03：多个参数：指定条件的值的下标、带值输出，替换等结果的展示

A := array((1, 2, 3, 4, 5), (2, 3, 4, 5));
B := Mfind(A, Mcell > 3);
C := Mfind(A, Mcell > 3, true);
D := Mfind(A, Mcell > 3, false, 3);

B 与 D 的结果为： C 的结果为(列名为 2 的为该项的值)：

// 执行完 D:=Mfind(A,Mcell>3,false,3);后，数组 A 的结果为：

PS：C 和 B 的结果的差异就是 C 多出一列为符合条件的值，而 0 列为行标，1 列为列标。

D 的结果与 B 一致，而数组 A 的结果中>3 的值被替换成 3

MFind 单参数模式

Mfind(Matrix:array):array;

Mfind 在一个参数的时候，则为查找为真的下标，如果参数为一个一维数组，则其返回的结果集也为一个一维数组

例如：找出数组中指定列符合指定条件的子集

// 假定有随机数组 b 如 b:=rand(1000,10);
select 的代码 c := select \ * from b where [0] > 0.5 end;可以获得列 0 大于 0.5 的子集
// 可以很便捷地使用矩阵模式代码替代：c:=b[mFind(b[:,0].>0.5)];

即

b := rand(1000, 10);
c := b[mFind(b[:, 0] . > 0.5)];
return c;

c 的结果为第 0 列数值大于 0.5 的那些行集合。

其中，理解运行步骤：

第一步：b[:,0].>0.5 得到一个一维的真假数组，即值大于 0.5 的行为真，否则为假。

第二步：mFind(b[:,0].>0.5)获得元素值为真的行标集合，

第三步：b[mFind(b[:,0].>0.5)]根据指定行标集合获取子矩阵，即获得了符合条件的 b 的子集。

MFind 矩阵查找

MFind 可以查找矩阵中的符合条件的行列以及值。

例如，我们在一个随机矩阵中寻找值大于 0.9 的值所处在的位置：

A := Rand(10, 10);
B := MFind(A, MCell > 0.9);

B 的返回结果为一个二维数组，第 0 列为符合条件的行号，第 1 列为符合条件的列号。

如果我们除了要返回行列号，还需要返回符合条件的结果，则用 MFind(A,MCell>0.9,True)即可，这样第 2 列为符合条件的值。

在查找的时候，第二个参数为一个条件表达式，我们可以利用 MCell 获得值，也可以利用 MRow 获得行下标，MCol 获得列下标，所以我们也可以做出复杂的查询。

复杂应用案例：

例如：

A 为矩阵，内容为股票的最近 N 日的日期，我们假定我们的范例中的股票均已上市 N 日以上。

N := 100; // 一百个交易日
A := Zeros(N, array("SZ000001", "SZ000002")); // 得到一个N行两列的0矩阵，列名为股票代码
Cols := MCols(A, 1);
for j := 0 to length(Cols) - 1 do//初始化时间数组
begin
    SetSysParam(pn_stock(), Cols[j]);
    SetSysParam(pn_date(), now());
    A[:, j:j] := `NDay3(N, sp_time()); // 给第J列赋值为时间
end;
B := MFind(A, Spec(SpecDate(Close() > Ref(Close(), 1) * 1.02, MCell), MCol), 1); // MCell为时间，MCol为股票代码
return B;

返回的 B 的结果为股票涨幅大于 2%的股票和时间。

MFind 矩阵替换

Mfind 处理可以用来查找，还可以用 Mfind 替换掉特殊值，例如：

A := Rand(10);

Mfind(A,Mcell>0.9,NIL,0.9);可以将大于 0.9 的值替换为 0.9

Mfind 用于将逻辑数组变换为下标数组

在 TSL 的子矩阵下标值允许使用下标数组，而某些矩阵语言则还允许使用逻辑数组，即只取出为真的下标，MFIND 可以将逻辑数组转换为下标数组。

A := Rand(100, 3);
B := A[:, 0] . > 0.5; // 返回0列为真的逻辑数组
C := Mfind(B); // 返回为真的下标数组
D := A[C]; // 取出A的子矩阵

等价写法：D := A[Mfind(A[:, 0] .> 0.5)]，等同于 D := select * from A where [0] > 0.5 end;。

MRow

说明：行下标。遍历矩阵时，MRow 返回当前行下标。

MCol

说明：列下标。遍历矩阵时，MCol 返回当前列下标。

MCell

说明：单元格值。遍历矩阵时，MCell 返回当前单元格值，也可对 MCell 赋值以修改。

MIndexcount

说明：多维矩阵遍历时，MIndexCount 表示当前元素所在的总维度。范例：

打印当前遍历时的维度数。

a := Rand(2, 1, nil, 2); // 2*1*2 的三维数组
r := array();
a:.
begin
    echo mIndexCount; // 三维数组，当前维度为 3
end;

MIndex

说明：多维矩阵遍历时，MIndex(N) 表示第 N 维的下标。范例：

a := Rand(3, 4, nil, 5); // 三维数组
a[:, :, :]::
begin
    echo mIndex(0), "->", mIndex(1), "->", mIndex(2), "->", mCell, "\r\n";
end;
return 1;

打印各维度下标结果：

::

矩阵遍历算符，支持子矩阵循环。

B := array();
A := array((1, 2, 3), (2, 3, 4));
A::begin
    B[mRow][mCol] := mCell;
end;

对 A 遍历时给 B 赋值，结果 B 与 A 相同，等价于 B := A。

::=

矩阵遍历赋值算符，支持子矩阵循环赋值。

b := array(-1, 2, 3, -5);
b : := abs(mcell);

B 的结果为 array(1,2,3,5)

::=矩阵遍历设置值

绝大多数 TSL 语言的基础函数已经支持矩阵计算。

如果某个函数不支持矩阵，可用 ::= 将其逐元素应用到矩阵或数组。

示例：

a := array(-1, "AAA", 1);
a := ifReal(a);
a : := ifReal(mcell);

mcell 表示当前遍历单元的值。而 MCell 可以获得当前遍历的项的值，所以 ifReal(MCell)就是判定当前遍历项是否为浮点数。

同样，:.=也有该功能。

::=的复杂应用-取数据

::= 也可用于按行列索引生成矩阵结果。例如，数组列下标为时间字符串，行下标为股票代码：

stks := array("SZ000001", "SZ000002");
times := array("2008-12-31", "2007-12-31", "2006-12-31");

我们要一次性获得这些股票在这些时间的收盘价，怎么做呢？

a := zeros(stks, times); // 生成列下标为时间字符串、行下标为股票的矩阵
a : := spec(specDate(close(), strToDate(mcol)), mrow);

检查下结果，内容是否是你想象的结果呢？

这里边，使用了 MCol 获得当前的列下标，MRow 获得当前的行下标，我们再利用了 Spec 和 SpecDate 函数，计算出了指定股票指定时间的收盘价。最后生成了一个收盘价矩阵。

同样，上面的 ::= 改用 :.= 也可以。

矩阵的多维遍历

对矩阵使用 ::/::= 只能做二维遍历，结合子矩阵算符可进行多维遍历。遍历的时候用 mIndex(N)可以访问第 N 维下标，mIndexCount 可以访问维度数。

a := Rand(10, 10, nil, 10);
a[:, :, :] : := mIndex(0) * mIndex(1) * mIndex(2);

可以给一个三维矩阵赋为一个乘法矩阵。

利用矩阵循环赋值使不支持矩阵的函数支持矩阵

绝大多数 TSL 语言的基础函数已经支持矩阵计算。

如果某个函数不支持矩阵，可使用 ::= 逐元素应用函数；:.= 会遍历到最深维度。

示例：

a := array(-1, "AAA", 1);
a: := ifReal(mCell);

例如，用户自定义一个分类函数并对集合逐元素应用：

function VFlag(v)
begin
    if v > 50 then
        return ">50";
    if v > 0 then
        return "(0,50]";
    if v == 0 then
        return "零";
    if v > -50 then
        return "[-50,0)";
    return "<-50";
end;

t := array(-999, 100, -3, 30, 0, -5);
t: := VFlag(mCell);
return t;

MfindSparse

范例

范例 01：对比 MFindSparse 与 MFind

t := array(1, 2, 0, ('A': array(2), 'B': 2), ('A': array(1, 2), 'B': 12));
return MFindSparse(t);

t := array(1, 2, 0, ('A': array(2), 'B': 2), ('A': array(1, 2), 'B': 12));
return MFind(t);

差异要点：

MFindSparse 的结果统一为二维数组，可深入到更深维度。
MFind 最多判断到二维，返回的下标维度更浅。

范例 02：指定条件

t := array(1, 2, 0, ('A': array(2), 'B': 2), ('A': array(1, 2), 'B': 12));
return MFindSparse(t, mCell = 2);

t := array(1, 2, 0, ('A': array(2), 'B': 2), ('A': array(1, 2), 'B': 12));
return MFind(t, mCell = 2);

更多范例可参考 MFind。

:.

矩阵深度遍历算符，不假定维度数，而是对数组的节点进行深度遍历。是对::算符的功能扩展，使用方式和::一致，对于 fmarray 而言行为一致，但对于数组 Array，::最多只能遍历两维，而:.是遍历到最深维度。

一般用法同：：，比如对二维数组的遍历：

B := array();
A := array((1, 2, 3), (2, 3, 4));
A:.begin
    B[mRow][mCol] := mCell;
end;

说明：对 A 遍历并写入 B，最终 B 与 A 内容相同，相当于 B := A。再比如，多维数组与不完全矩阵的遍历差异：

t := array(10, 12, ("A": (30), "B": 22), ("A": (31, 32), "B": 23));
t2 := array();
k := 0;
t:.begin
    mc := mIndexCount; // 总维度
    k := k + 1;
    t2[k] := array("v": mCell, "总维度": mc);
end;
return t2;

t := array(10, 12, ("A": (30), "B": 22), ("A": (31, 32), "B": 23));
t2 := array();
k := 0;
t::begin
    mc := mIndexCount; // 总维度
    k := k + 1;
    t2[k] := array("v": mCell, "总维度": mc);
end;
return t2;

:. 遍历到最深维度，:: 最多遍历到二维。

:.=

矩阵深度遍历赋值算符，不假定维度数，对数组节点进行深度遍历并赋值。是对 ::= 的扩展：::= 最多遍历到二维，:.= 遍历到最深维度。

示例：

b := array(-1, 2, 3, -5);
b:.= abs(mCell);

结果：array(1, 2, 3, 5)。

对比 :.= 与 ::=：

t := array(("A": (30, "tsl"), "B": "Tinysoft"), ("A": (31, 32), "B": 23));
return t:.= ifnumber(mCell);

t := array(("A": (30, "tsl"), "B": "Tinysoft"), ("A": (31, 32), "B": 23));
return t: := ifnumber(mCell);

:.= 遍历到最深维度，::= 最多到二维。

矩阵运算

基础算符对矩阵计算的支持

TSL 的基础算符+,-,*,/,,%,mod,div,^,~,.=,.>,.<,.<>,.>=,.<=,.!,.&,.|,.^,.||,.&&,.!!,like,++,--都支持矩阵（数组）的计算,可以支持简单类型和矩阵进行计算，也支持矩阵和矩阵一起进行计算。

用二元运算符支持矩阵对矩阵，矩阵对常量，常量对矩阵,加法为例：

array(1,2,3)+array(2,3,4)为 array(3,5,7)

1+array(1,2)和 array(1,2)+1 为 array(2,3)

和其他的支持矩阵计算的语言不同，TSL 的基础的算符对矩阵计算依旧是原来基础算符的含义，例如矩阵和矩阵用*来计算，是每个相应单元格之间相乘。

基础算符的运算既支持二维数组（矩阵），也支持一维数组或者其他维度的数组。

默认情况下，也支持对非完全矩阵的计算，即当对应位置不存在时或为 nil 时，当 0 处理。

例如：Array(“A”:100,”B”:200,”C”:300)+array(“A”:1,”C”:3,”D”:4)

可以计算的结果为 Array(“A”:101,”B”:200,”C”:303,”D”:4)。

若希望该种计算时进行报错或提示，可通过系统参数设置 FAQ：Q：CalcCTRLWord 系统参数设置：控制 nil 参与计算以及浮点除 0 的警告或者出错

例子 1：矩阵和简单类型的计算。

A := array(1, 2, 3);
A := A + 1; // 该写法也可以写成 A+=1;
// 结果A是array(2,3,4)也就是每个单元格都加1。
A := Ones(10, 10); // 初始化一个全1的10*10矩阵。
A := A * 3;
// 结果A是一个10*10的全3矩阵。

例子 2：矩阵和矩阵的计算

A := array(1, 2, 3);
B := array(2, 3, 4);
A := A * B; // 也可以写成 A *= B;
// 结果 A 是 array(2, 6, 12)
A := Eye(10, 10);
B := Ones(10, 10);
A := A + B;
// 结果 A 是对角线为全 2、其他为全 1 的矩阵。

例子 3：非完全矩阵的计算-矩阵与矩阵的大小不一致时的计算

A := array("A": 1, "B": 1, "C": 1);
B := array("A": 2, "C": 2);
return A + B;
// 结果 A 为：array("A": 3, "B": 1, "C": 3)

目前，矩阵和矩阵以及矩阵和简单类型的计算支持所有常用的基础算符有+，-,*,/,,mod,div,^,~等简单算符。

支持不同维度的矩阵计算规则：

标量与矩阵：对每个单元格逐元素运算。
矩阵与矩阵：对应单元格逐元素运算。

支持的运算符：+, -, *, /, \, mod, div, ^, ~, .= , .>, .<, .<>, .>=, .<=, .&, .|, .!, .^, shl, rol, shr, ror, .&&, .||, .!!, like, ++, --。

范例：

范例 1

// 实数与数组相加
num := 5;
arr := array(1, 2, 3, 4, 5);
return num + arr;
// 返回：array(6, 7, 8, 9, 10)

范例 2

// 数组与数组相加
arr1 := array(1, 2, 3, 4, 5);
arr2 := array(6, 7, 8, 9, 10);
return arr1 + arr2;
// 返回：array(7, 9, 11, 13, 15)

范例 3

// 一维数组与二维数组相加
arr1 := array(1, 2, 3, 4, 5);
arr2 := Ones(5, array("a", "b", "c"));
return arr1 + arr2;

范例 4

arr := array(1, 2, 3, 4, 5);
return ++arr;

返回：array(2, 3, 4, 5, 6)。

矩阵转置算符

` 表示矩阵转置（行列互换）。

a := array((1, 2, 3), (2, 3, 4));
a := `a;

A 的结果为 array((1, 2), (2, 3), (3, 4))。

转置对一维数组进行转置得到的结果为一个列向量。

a := array(1, 2, 3);
a := `a;

A 的结果为 array((1), (2), (3))。

Union 矩阵行相加算符

Union 可以把两个矩阵的行连接起来，例如：

a := array((1, 2, 3), (2, 3, 4));
b := array((11, 22, 33), (22, 33, 44));
a := a union b;

A 的结果为 array((1, 2, 3), (2, 3, 4), (11, 22, 33), (22, 33, 44))。以上也可以写成 A&=B;记住这个是个特例，TSL 采用了&=而不是 union=，这更直观。

事实上，union 对一维数组同样有效，例如 array(1,2) union array(3,4)的结果为 array(1,2,3,4)

如果需要将一个一维数组加到一个二维数组的最后一行，怎么做呢？

我们把一个一维数组转置两次，就可以获得一个二维的横向量。

例如

a := array((1, 2, 3), (2, 3, 4));
b := array(3, 4, 5);
a := a union ``b; // ``两次转置

|矩阵列相加算符

|可以把两个矩阵的列连接起来，例如：

A := array((1, 2, 3), (2, 3, 4));
B := array((11, 22, 33), (22, 33, 44));
A := A | B;

A 的结果为 array((1, 2, 3, 11, 22, 33), (2, 3, 4, 22, 33, 44));

以上也可以写成 A|=B。

事实上，|对一维数组同样有效，例如 array(1,2) | array(3,4)的结果为 array((1,3),(2,4))

也支持直接将一个一维数组直接用|加到一个二维数组上。

:|非完全矩阵列相加算符

:|和|类似，都可以把两个矩阵的列连接起来。但两者又有差异，|的处理是按照每行进行进行 union，在处理非完整矩阵的时候，这个时候结果会出现和预计的不一样。

A := array((1, 2, 3), (2, 3));
B := array((11, 22, 33), (22, 33, 44));
A:| = B; // 也可以写成A := A:|B;

A 的结果为 array((1, 2, 3, 11, 22, 33), (2, 3, nil, 22, 33, 44));
// 如果采用 A|=B 结果就会是 array((1,2,3,11,22,33),(2,3,22,33,44));

！求逆与广义逆

矩阵求逆

！可以将矩阵求逆，例如：

A := array((1, 2), (5, 8));
A := !A;

A 的结果为 array((-4,1),(2.5,-0.5))

当矩阵为奇异矩阵或者非方阵的时候，！会自动计算其广义逆。

A := array((1, 2, 3), (3, 5, 6));
A := !A;

A 的结果为

array(

(-1.21052631578947,0.578947368421051),

(-0.789473684210525,0.421052631578947),

(1.26315789473684,-0.473684210526314))

对于某些不完全的奇异矩阵，如果需要用广义逆而非逆计算，需要使用函数 pinv。

:*矩阵乘法

与一些矩阵计算语言不同，TSL 语言相当于.,矩阵乘为:*

A := array((1, 2, 3), (2, 3, 4));
B := array((2, 3, 4, 5), (3, 4, 5, 6), (5, 6, 7, 8));
A := A: * B;

A 结果为

array(

(23.00,29.00,35.00,41.00),

(33.00,42.00,51.00,60.00))

// 上述写法也可以为：A:\*=B;

:/矩阵除法

与某些矩阵计算语言不同，TSL 语言的/相当于./，而矩阵除法采用:/

A:/B 的算法为 A:*!B

当 B 为非方阵的时候，!B 采用广义逆。

:\矩阵左除

A:\B 的算法为!A:*B

当 A 为非方阵的时候，!A 采用广义逆

:^矩阵乘方

TSL 用:^表示矩阵乘方

例如 A:^3 等于 A:*A:*A，乘方应该是个方阵。

子矩阵运算

子矩阵-取子矩阵

以下均假设 A 是一个矩阵。

数组取数是使用[]运算符，例如 A[2,3]表示行下标为 2 列下标为 3 的值。

如果要取出第 2 到第 5 行，第 3 到第 6 列的值，TSL 是怎么支持的呢？

事实上：A[2:5,3:6]就可以描述了。注：序号从 0 开始。

如果需要 2 到第 5 行，如果取出下标为 3 的列的值返回为一维数组，则可以采用 A[2:5,3]，如果依旧返回一个矩阵，则采用 A[2:5,3:3]。

：两边的开始和截止序号均可以省略。

例如，A[:,3:6]表示第三列到第 6 列的数据，用户也可以用 A[3:,3:6]来描述第 3 到第 6 列的从第 3 行到最后一行的数据。

常用取子矩阵的用法：

取第三行作为子矩阵（二维数组）

A[3:3,:]

取第下标为 3 的行向量作为一维数组

A[3,:]

取第三列作为子矩阵

A[:,3:3]

取下标为 3 的列向量作为一维数组

A[:,3]

取下标为"A"的列向量作为一维数组

A[:,"A"]

子矩阵-一维取子矩阵

对一维数组取子矩阵,可以通过 t[n:m]方式提取出数组 t 的行下标从 n 到 m 的子集。

// 假定一个一维数组 A,值为 a:=array(1,2,3,4,5)，我们需要取出其下标从 1 到 3 的值，我们用 A[1:3]即可。
// 如果 A 是一个矩阵，a:=array((1,2,3),(2,3,4),(3,4,5),(4,5,6));

我们一样可以用 a[1:3]这样的结果和 a[1:3,:]是一样的，因为对于 TSL 语言而言，二维的数组就是一维的一维数组。

子矩阵-利用下标数组取

有的矩阵语言支持用下标序列数组来取子矩阵，TSL 同样支持。

我们先看对一个一位数组怎么取，假定有数组：

A := array(1, 2, 3, 4, 5, 6, 7);

如果我们要取出下标为 2,4,6 的数组项作为子数组，我们可以用

b := a[array(2, 4, 6)];

B 的结果为 array(3, 5, 7)。

如果 A 是一个矩阵：

a := array((1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6), (5, 6, 7));

如果要取出行 1、3、4，列 0、2 的子矩阵：

b := a[array(1, 3, 4), array(0, 2)];

B 的结果为 array((2, 4), (4, 6), (5, 7))。

子矩阵设置-给子矩阵的内容赋值为确切简单值

a := zeros(10, 10);
a[1:8, 1:8] := 1;

A 的结果为周边为 0，里边为 1 的矩阵

子矩阵设置-给子矩阵赋值一个同等大小的矩阵

a := zeros(10, 10);
a[1:8, 1:8] := eye(8, 8);

A 的结果为周边为 0，里边为一个 8*8 单位矩阵。

子矩阵循环赋值::=

::= 除了支持矩阵循环赋值，还支持对子矩阵逐元素赋值。例如:

a := zeros(10, 10);
a[1:8, 1:8] : := mrow * mcol;

A 的结果为：

多维矩阵的子矩阵

TSL 支持多维矩阵的子矩阵。

a := rand(8, 8, nil, 8, 8); // 8*8*8*8 的四维矩阵
b := a[:, 0, :, :]; // b 为一个三维矩阵
c := a[:, 3:5, 0, 0]; // c 为一个二维矩阵
a[:, :, 0, 0] := 1; // 给第 3、4 维为 0 的位置设置 1
a[3, :, :, 5] := rand(8, 8); // 给指定子矩阵设置新的二维随机矩阵

子矩阵循环

::除了可以直接对矩阵进行循环，还可以对子矩阵进行赋值修改。

a := array((1, 2, 3), (2, 3, 4), (3, 4, 5));
a[1:2, 1:2] :: begin
    mcell := mcol * mrow;
end;

子矩阵算符对字符串下标的处理规则

对于有字符串下标的矩阵，我们的子矩阵算符:一样是支持的，但是:支持的依旧是序号。

a := array("A": 1, "B": 2, "C": 3, "D": 4);
b := a[1:2];

B的结果是什么呢？

答案如下：

因为 B 下标的序号为 1，C 小标的序号为 2。

但是如果要用下标数组去取值，则数组内应该为下标的值，而非序列。

b := a[array("B", "C")];

不要使用 b := a[array(1, 2)] 来表示字符串下标。

子矩阵计算进行字符串下标和数字下标的转换

我们可能经常需要利用字符串下标数组进行显示，而使用数字下标数组进行运算，这样经常会需要有互相转换的方法。

例如我们要把一个 array((1,2,3),(2,3,4))的数组 A 转换到名为 B 的字符串下标数组 array(("A":1,"B":2,"C":3),("A":2,"B":3,"C":4))。

我们可以写如下代码：

A := array((1, 2, 3), (2, 3, 4));
B := Nils(2, array("A", "B", "C"));
B[:, :] := A;

反过来一样可以

B := array(("A":1, "B":2, "C":3), ("A":2, "B":3, "C":4));
A := nils(2, 3);
A[:, :] := B;

矩阵的重构与下标的变换

矩阵的重构：Reshape 函数可以将一个多维数组拉伸为一维数组，或重构为指定大小的矩阵。

例如：

A := Rand(3, 6);
B := Reshape(A); // B为拉伸的长度为18的一维数组
C := Reshape(A, 2, 9); // 产生2*9的矩阵
D := Reshape(A, 6, array(“A”, “B”, “C”)); // 产生6行3列矩阵
E := Reshape(A, array(“A”, “B”, “C”, “D”, “E”, “F”), array(“F1”, “F2”, “F3”)); // 全下标指定的方式产生矩阵。
F := Reshape(A, 3, 3, 2); // 产生一个3*3*2的三维数组

ReIndex,ReIndexCopy 下标变换：这两模型可以修改数组的指定下标为新下标，区别在于 Reindex 直接修改原数组，而 ReindexCopy 不修改原数组，通过返回产生一个修改后的数组。

如：

A := array("A":0, "B":1, "D":2, "E":3);
ReIndex(A, array("A":"A1", "D":nil));

A 的结果变为： array("A1":0, "B":1, "E":3);

参数 array("A":"A1","D":nil)的含义是：将字符串下标"A"改为"A1"，把字符串下标"D"删除。

如果我们要对多维数组进行处理，假定我们有：

A := rand(10, array("A", "B", "D", "E"); // 初始化一个四列的二维矩阵
ReIndex(A, nil, array("A":"A1", "D":nil));

第 2 个参数为 nil 表示对第一维的下标不进行变动，因此我们修改列"A"为"A1",并删除"D"列。

更多维的处理以此类推。

利用 Reindex 也可以做下标的交换

例如：

A := array(1, 2, 3, 4, 5);
reIndex(A, array(0:4, 4:0));

A 的结果为 array(5, 2, 3, 4, 1);

矩阵与函数

支持矩阵的基础函数

大多数 TSL 的基础函数是支持矩阵的，例如：abs，我们可以用 abs(array(-1,-2,3))得到一个 array(1,2,3)，我们也可以对任意维度的矩阵使用 abs 函数。

这类简单函数在支持矩阵批量运算时，若存在异常值，可通过函数末尾的参数两个可选参进行控制（即在原始函数定义的基础上增加了两个可选参数），其功能分别为：

Opt1：异常值处理，指定为 0 表示不做处理（默认情况）;为 1 表示计算跳过 nil 值;为 2 表示跳过所有的异常值；

Opt2: 报错填充值，当某单元报错的时候，使用该参数填充。

具体使用可参考下列子节点介绍。

基础函数 NIL 值的处理

若数组中存在 nil 异常值，则可通过在末尾增加第一个可选参数，参数值给 1 对 nil 值进行跳过处理。

以一维数组为例：

A := array(1, -2, nil, 3);
B := Abs(a); // 会返回错误，因为其中有NIL值。如果要允许NIL值，使得原位置保留NIL,则使用
B := ABS(A, 1); // 末尾增加一个可选参数，对nil进行跳过处理，这样B的值为Array(1,2,NIL,3)

基础函数错误值处理

如果矩阵的内容里有错误的值，则可通过在末尾增加第一个可选参数，参数值给 2 进行跳过处理。

例如本来应该是数字的，结果出现的是字符串，例如：

A := array(1, -2, "AAA", nil, 3);

这样使用 Abs(A,1)照旧会出错，这个时候可以使用 Abs(A,2)来允许错误值的出现，错误值为其自身。

B := Abs(A, 2);

B 的结果为 Array(1,2,"AAA",nil,3)

基础函数错误值的替代

如果矩阵的内容里有不被许可的值，但又希望替代掉这些错误的值，我们可以再增加一个参数：

A := array(1, -2, "AAA", nil, 3);
B := Abs(A, 0, 0); // 第二个0为替代的值
C := Abs(A, 1, 0);
D := Abs(A, 2, 0);

当第一个附加参数为 0 的，表示 nil 和其他错误都为错误，错误位置均设置为 0，那么 B 为 Array(1,2,0,0,3); 当第一个附加参数为 1 的，表示 nil 允许，但是其他错误不被允许，因此 nil 被保留，而"AAA"被设置为 0，因此 C 为 Array(1,2,0,nil,3); 由于第一个附加参数为 2 代表了错误也可以接受，所以 D 为 Array(1,2,"AAA",nil,3);

基础函数的附加参数说明

以 Abs 和 RoundTo 为例：

对于标准的 Abs 定义：Abs(Data:Double)

我们有扩展的版本为：Abs(Data[;ErrDefine:Integer[;ErrReplace]])

其中，Data 为数字或者数组（可以多维）

ErrDefine 允许为 0,1,2，当为 0 的时候不允许错误值和 NIL 值，1 为允许 NIL 值不允许错误值，2 为错误值保留为原始值

ErrReplace 当 ErrDefine 为 0,1 的之后以 ErrReplace 替换掉错误位置

使用如：Abs(array(1,nil,'AAA',-100),0,'-')返回：array(1,'-','-',100)

对于多参数的基础函数，ErrDefine 和 ErrReplace 总是可以作为可选参数添加在最后。

以原本为两个参数的 RoundTo 为例:

A := array(0.06, 0.001, nil, "AAA", 0.98);
B := RoundTo(A, -1,
0, 0
);

可以用增加两个参数，第一个表示不处理异常值，第二个表示异常报错时用 0 替代，则 B 结果返回 Array(0.1,0.0,0,0,1.0)

多参数的基础函数矩阵规则

如果一个函数是多参数的，我们遵循的矩阵处理原则为：为每一个参数寻找一个或者一组匹配者

例如（RoundTo 有两个参数：值与保留位数）：

RoundTo(array(1.6, 2.9, 3.8), 0); // array(2.0, 3.0, 4.0)
RoundTo(1.3467, array(0, -1, -2, -3)); // array(1.0, 1.3, 1.35, 1.347)
RoundTo(array(1.5, 2.9, 3.8), array(-1, 0, 0)); // array(1.5, 3.0, 4.0)

多参数与变参的矩阵处理规则同理：按位置匹配并逐元素计算。

支持标量和多维矩阵的基础函数

常见函数如 Arccos、Arcsin、Tan、Cotan、CosH、SinH、LnXp1、Log10 等均支持矩阵输入；完整列表请参考函数库（数学函数）。

基础统计函数对二维数组的处理

基础统计函数支持对二维数组的处理，并支持选择行列操作，指定移动步数，选择部分字段以及异常处理模式后再做统计。

这些功能分别由五个可选的附加参数进行控制，依次分别为：

RowCol: 为 0 表示对列，为 1 表示对行。缺省时对列统计

MovingN: 移动点数，为 0 或者缺省表示不移动。

Range: 统计的范围，允许为下标或者下标数组。指定行/列或者行/列组进行统计。缺省为 NIL 表示全部。

ErrAndMovingSkip: 错误控制以及移动跳过错误数据的控制。低两位的值为（0 为允许 NIL，1 为允许错误，2 为不允许 NIL 和错误)，第三位为 1 则表示移动时跳过错误数据，三个位在一起的取值组合为 0,1,2,3,4,5,6,7。

EmptyResult:空数组的返回值。

基础统计函数统计支持指定行列

统计函数对二维数组进行计算时，默认以列为统计对象进行分别统计。若需要对每行进行统计，则可增加第一个附加参数，并设置为真。

例如：

以 Mean 平均值为例

A := Rand(10, array("A", "B"));
a[:, "A"] := 0 -  > 9;
a[:, "B"] := 2 -  > 11;

B := Mean(A)的结果为：
C := Mean(A, true)的结果为：

也就是说，在基础统计函数后的第一个附加参数为指定统计以行或以列统计,若为真表示行统计,为假或者缺省则为列统计

基础统计函数统计支持移动

默认情况下，对整列或整行进行统计，要需要指定统计移动点数，则可增加第二个附加参数，值为指定的移动点数。

如有数组 A，生成如下：

A := Rand(10, array("A", "B"));
A[:, "A"] := 0 -  > 9;
A[:, "B"] := 2 -  > 11;

D := Mean(A, false, 3); // 指定步长为 3，即统计当前行最近的 3 个值的平均

其结果为

以列的移动 3 个数据点的平均值，第二个附加参数的值为移动点数

基础统计函数指定内容统计

默认情况下，对所有行或列进行统计，要需要指定统计范围，则可增加第三个附加参数，值为统计的列或行下标或下标数组，缺省为 NIL 表示全部。

以 Mean 平均值为例

A := Rand(10, array("A", "B"));
a[:, "A"] := 0 -  > 9;
a[:, "B"] := 2 -  > 11;

如果我们仅仅只需要求出”A”列的平均值

E := mean(a, false, 0, "A");

那么 E 的值为 4.5

如果我们需要”A”列的移动 3 日平均用 Mean(a,false,3,"A")即可

我们知道第三个附加的参数的内容为需要指定的行列（第一个附加参数决定是行还是列）

如果我们要多个列，第三个附加参数可以用数组

例如 Mean(a,false,0,array("A","B"))得到”A”列和”B”列的平均值

基础统计函数的错误数据处理

和 abs 这类函数不同，基础统计函数默认是允许有 nil 值的，例如

A := array(1, 2, 3, nil, 4);
B := array(1, 2, 3, "ABCD", 4);
C := Mean(A);
D := Mean(B);

C 的结果为 2.5，但 Mean(B)会报错。

如果要允许跳过错误的数据，我们可以这么写：

D := Mean(B, false, 0, nil, 1);

如果我们要让存在 NIL 的值也报错，则使用:

C := Mean(A, false, 0, nil, 2);

这个附加的第四个参数为错误数据处理：

其低二位允许为三种值：0,1,2，其中0表示允许NIL，1表示允许跳过错误值，2表示不允许NIL和错误值

在做移动平均的时候，存在这样的问题：

假如前边存在有错误值/NIL 值，到底移动的 N 是将其计算在内还是不计算在内呢？

其现实意义为：假定非交易日的值为 NIL，在移动平均的时候是计算自然日内的平均还是交易日内的平均呢？

我们可以举一个例子：

A := array(1, 2, 3, nil, 4, 5);
B := Mean(A, false, 3);

从 4,5 下标行来看，我们在默认情况是将 NIL 计算在移动的 3 日内的

在下标 4 移动 3 日的内容为：4,NIL,3,其均值为 3.5

下标 5 移动 3 日的内容为:5,4,NIL,其均值为 4.5

如果我们希望在移动的时候跳过那些错误的值：

C := Mean(A, false, 3, nil, 4);

这样，下标 4 移动的值为 4,3,2 其均值为 3

下标 5 的移动的值为 5,4,3 其均值为 4

也就是说第 4 个附加参数，当设置为 4 的时候是跳过 NIL 值

基础统计函数第四附加参数说明

第四个附加参数有两个用途：

一个是用于控制是否允许 NIL，是否允许错误数据。

另一个则是控制在移动的时候是否跳过错误值。

即主要用于异常值处理的参数，该参数值由 3 位二进制位来进行控制（默认为 0）：

第一位管理的是是否忽略异常值(不包括 nil)，即 1 不报错，0 报错。

第二位管理的是 nil 值是否报错，即 1 报错，0 不报错。

第三位管的是计算移动长度的时候，nil 值及字符串等异常值是否包括在内。即 0 不忽略，1 忽略。

如此，衍生出 8 种组合场景，分别对应如下：

二进制	十进制值	功能说明
0b000	0	默认值，异常值报错，nil 不报错，移动时异常值不忽略
0b001	1	异常值不报错，nil 不报错，移动时异常值不忽略
0b010	2	异常值与 nil 报错，移动时异常值不忽略
0b011	3	异常值不报错，nil 报错，移动时异常值不忽略
0b100	4	异常值报错，nil 不报错，计算移动时忽略异常值
0b101	5	异常值与 nil 不报错，计算移动时忽略异常值
0b110	6	异常值报错，nil 报错，计算移动时忽略异常值
0b111	7	异常值不报错，nil 报错，计算移动时忽略异常值

注：上述说明中“移动时中提到的异常值”包括 nil 值在内，而其它处异常值中则不包括 nil 值在内。

第五附加参数：空数组的统计值

在统计的时候，对空数组的处理是一件麻烦的事情，例如：

Mean(Array())的结果到底是多少呢？

TSL 默认处理成 0，而有的系统则处理成 NaN

到底应该是多少，这并不是一个纯粹的数学问题，而和应用相关。由于使用频度不大，我们将这个空数组的返回值放在相对靠后的附加参数中。

Mean(Array(),false,0,nil,0,NaN)的结果为 NaN，

甚至于你还可以这么用：

Mean(Array(),false,0,nil,0,"空数组")来得到”空数组”这个字符串。

支持一维数组和二维矩阵的基础统计函数

常见函数如 Large、Small、Percentile、Mean、Sum、Median 等均支持一维数组与二维矩阵；完整列表见函数库（统计函数）。

FMArray

FMArray 数组的简介

FMArray 是一种紧缩式存贮的高效运算的支持多维度的矩阵式数组。其大小固定、单元类型一致，与 Array 形成互补，比 Array 的运算效率高，但没有 Array 使用那么灵活，需要做高效矩阵计算或算法开发时可以使用。

特性总览

1 支持多维度的矩阵式数组

2 FMArray 属于完全矩阵，不支持稀疏矩阵，

3 每一维度的下标严格从 0 开始，即不支持字符串等其它下标。

4 每一个单元格的数据类型是相同的，而且不允许运行时进行修改。

5 单元格的数据类型目前支持整数、64 位数数(L)、浮点数三种数据类型，其它数据类型暂不支持。

6 存贮是紧缩式的，因此数据读取访问以及构建的效率非常高

7 紧缩式存贮结构的特点，导致像 Array 那样随意对其进行维度以及长度的改变可能会存在性能的严重损失

8 支持基础算符，支持绝大多数基础统计函数，支持 SQL 语法，支持集合运算，支持子矩阵运算，支持 MFIND 操作等

9 支持与 Array 类型进行转换，支持和 Array 进行混合计算，混合计算的效率会受到 Array 的影响

10 无大小约束，受限于平台或者语言设置的内存限额

主要用途

1 节约内存开销

2 极速的计算效率

3 更适合于算法的开发

4 采用 fmarray 尽量将计算在矩阵内解决

用法介绍

FMArray 数组的建构与初始化

常量建构模式

一维数组：

fmarray[1,2,3] 一维整数数组，内容 1，2，3

fmarray[1L,2L,3L] 一维长整型整数数组，内容为 64 位的 1，2，3

fmarray[1.0,2.0,3.0] 一维浮点数组，内容 1.0，2.0，3.0

二维数组：

fmarray1,2,3],[2,3,4 是一个 2 行 3 列的整数数组。

多维数组：

fmarray[1,1],[2,2],[3,3,2,2],[3,3],[4,4] 是一个 232 的三维数组

其它更多维度的数组依照此方式生成，fmarray 用[ ]表示维度，而 array 是用( )表示。

注：每个 fmarray 数组中的数据类型必须是一致的，否则会报错。

不支持构建空矩阵，FMArray 矩阵必需要有结构信息。

TSL 优化了 FMARRAY 的常量构造，如果存在巨大的 fmarray 常量数组，采用这种模式运行时相比 ARRAY 而言会有数个数量级的提升。

表达式建构模式

表达式建构模式即为在 fmarray[]中传入表达式的方式进行构造 fmarray 数组的方式。

如：fmarray[1+2,2+3,strtoint("3")] 得到的数组是 fmarray[3,5,3]

即，FMARRAY 和 ARRAY 类似，也支持单元格采用计算构建。

注：一旦 fmarray 里存在表达式，那么矩阵将会在运行时构建，因而无法获得优化的加持。

由于 TSL 语言目前并未进行常量的运算进行编译时优化，因而强烈建议不要使用无必要的常量运算。未来也许某个版本支持，但也会导致不同的 TSL 语言版本存在性能差异。

Minit

定义一：MInit(L1[,…LN],InitValue:[Int|Int64|Double]):FMArray

说明：初始化一个相同值的 N 维矩阵

参数：L1…LN 为维度 1 到维度 N 的长度

最后一个参数 InitValue 为初始化矩阵值的数字常量，可以为整型、长整型、浮点数。

返回：N 维矩阵

范例：

范例 01：

Fm1 := Minit(5, 3); // 初始化一个单元格全为3的长度为5的一维序列
fm2 := Minit(3, 2, 1L); // 初始化一个单元格全为64位的整数1的3*2的矩阵
Fm3 := Minit(2, 3, 4, 3.5); // 为初始化一个单元格全为3.5的2*3*4的三维矩阵

其中，return fm2;在客户端可以展示数组如下：

定义二：MInit(LArray:Array,InitValue:[Int|Int64|Double]):FMArray

说明：功能参照定义一，与定义一的区别是将维度放到一个 array 数组中，而不是 N 个可选参数，所以定义二的方式中，MInit 函数的参数只有两个。

参数：

LArray：维度长度数组，例如 array(2,3)就是初始化一个 2*3 矩阵，维度从 1 开始。

InitValue：为初始化矩阵值的数字常量。可以为整型、长整型、浮点数。

返回：N 维矩阵

范例：

范例 02：

// 将范例01中的三个数组的初始化，可以变更如下，效果一样
fm1 := Minit(array(5), 3);
fm2 := Minit(array(3, 2), 1L);
a := array(2, 3, 4);
Fm3 := Minit(a, 3.5);

MinitDiag

定义一：MInitDiag(L1[,…LN],InitValue:[Int|Int64|Double]):FMArray

说明：初始化一个对角线相同值的 N 维对角矩阵

如果 N 为 1，则效果同 Minit，创建的是一个值相同的一维数组。

多维对角矩阵即可理解为各维度下标相同的点为对角点。

参数：L1…LN 为维度 1 到维度 N 的长度

最后一个参数 InitValue 为对角线的数字常量，可以为整型、长整型、浮点数。

返回：N 维矩阵

范例：

范例 01：

// 初始化一个对角线为1的3*3的二维矩阵
Fmd := MinitDiag(3, 3, 1);
return Fmd;

定义二：MInitDiag(Larray:Array,InitValue:[Int|Int64|Double]):FMArray

说明：功能参照定义一。与定义一的区别是将维度放到一个 array 数组中，而不是 N 个可选参数，所以定义二的方式中，MInitDiag 函数的参数只有两个。

参数：

LArray：维度长度数组，例如 array(2,3)就是 2*3 矩阵

InitValue：为对角线的数字常量，可以为整型、长整型、浮点数。

返回：N 维矩阵

范例：

范例 02：

// 将范例01中的初始化变更如下，效果一样
Fmd := MinitDiag(array(3, 3), 1);
// 初始化一个3*2的对角线为1.0的矩阵
Fmd2 := MinitDiag(array(3, 2), 1.0);
return Fmd2;

MRand

定义一：MRand(L1[,…LN][,randominfo:array]):FMArray

说明：初始化一个 N 维随机数矩阵，随机矩阵是否是实数还是整数矩阵，取决于参数 RandomInfo

参数：L1…LN 为维度 1 到维度 N 的长度

RandomInfo：最后一个参数，矩阵随机类型，可省略，省略时返回的是 0 到 1 之间的随机数。

设定随机方法以及参数，详情参见 rand。

返回：N 维矩阵

范例：

范例 01：返回一个 0 到 1 之间的随机序列

return mrand(4);

范例 02：返回一个服从标准正态分布的二维矩阵

return mrand(4, 2, array("normal", 0, 1));

定义二：MRand(LArray:Array[,randominfo:array]):FMArray

说明：功能参照定义一。与定义一的区别是将维度放到一个 array 数组中，而不是 N 个可选参数，所以定义二的方式中，MRand 函数的参数只一个固定参数与一个可选参数。

参数：

LArray：维度长度数组，例如 array(2,3)就是 2*3 矩阵

Randominfo：矩阵随机类型，可省略，省略时返回的是 0 到 1 之间的随机数，详情参见 rand。

范例：

范例 03：

// 将范例01与范例02中的初始化变更如下f1与f2，效果一样
f1 := mrand(array(4));
f2 := mrand(array(4, 2), array("normal", 0, 1));
f3 := mrand(array(2, 3)); // 初始化一个2*3的随机数组
return f3;

数据类型的判断

在天软语言中，datatype(v)可以判断任意数据的数据类型，而 FMArray 数组的数据类型对应的是分类 27。

例如：Datatype(mrand(3)) ->类型是 27

也可以通示 ifFMarray(v)判断，若返回为真则为 FMArray 类型。

同时，datatype(fMarray,1)还可以判断 FMArray 数组中单元格数据的类型。

例如： Datatype(fmarray[1.0,2.0,3.1],1);->返回的是 fmarray 数组中单元格的数据类型 1（浮点数）。

Datatype(mrand(3),1) ->类型是 1，代表浮点

Datatype(mInit(3,0),1) ->类型是 0，代表整数

Datatype(mInit(3,0L),1) ->类型是 20，代表 64 位整数

ifFMArray

范例

范例一：默认对整个值判断

return ifFMarray(FMArray[1, 2, 3]); // 返回：1
return ifFMarray(array(1, 2, 3)); // 返回：0

范例二：对第一维度中的每个元素进行判断

return ifFMArray(array(FMArray[1, 2], 1, array(1, 2), nil, FMArray[[1, 2]], "abc"), -1);

返回：array(1,0,0,0,1,0)

单元格类型转换

可以用 integer,real,int64 三个函数转换 fmarray 的单元格数据类型到新的矩阵。

例如：将整型矩阵强制转换成实数矩阵

t := fmarray[1, 2, 3];
t1 := real(t);
return t1;

也支持多维矩阵，例如：

return real(fmarray[[-1, 2], [3, 4]]);

FMArray 与 Array 的相互转换

ArrayToFM

范例

范例 01：将存在实数与整型的数组转换成整型 fmarray 矩阵

t := array(1, 2, 3.5);
return arraytofm(t, 0); // 此处的第二个参数0为一个整型，所以转换结果为一个整型的fmarray

而若将第二个参数变更为 0.0，即

t := array(1, 2, 3.5);return arraytofm(t, 0.0);

则返回：

同样，若将第二个参数为更为 0L，则返回的 fmarray 结果为：fmarray[1L,2L,3L]其中，0，0.0，0L 也可以是其它任意数值，比如 5，5.5，5L 等。

MatrixToArray

范例

范例 01：将 fmarray 矩阵转换成 Array 数组

f21 := fmarray[[1, 2], [3, 8]];
return MatrixToArray(f21);

返回:（源串为：array((1,2),(3,8)) ）

矩阵大小

已有的矩阵大小运算的相关函数也支持 fmarray 数据类型。具体函数说明可参考各函数的帮助文档。

如常见的：

Length 返回第一维的长度

Msize 返回所有维度的大小或者下标

Mrows 返回第一维的长度或者全部下标

Mcols 返回第二维的长度或者全部下标

SetLength 重新设定矩阵的行数

注意：Msize 在 fmarray 的行为和 array 类型有所不同，array 类型的数据 msize 仅仅处理最多两维，而 fmarray 类型是全部维度。

功能展示如下：

f1 := fmarray[1, 2, 3, 8]; // 一维，4行
f2 := fmarray[[1.1, 2.0], [3.0, 8.5]]; // 2*2
f3 := fmarray[[[1, 1], [2, 2]], [[1, 2], [3, -3]], [[3, 8], [-8, -10]]]; // 3*2*2
// -Length返回整数，第一维度的长度
lenf1 := length(f1); // 返回4
lenf2 := length(f2); // 返回2
lenf3 := length(f3); // 返回3
// -msize(t) 返回一维数组，每个维度的长度
ms1 := msize(f1); // 返回array(4)
ms2 := msize(f2); // 返回array(2,2)
ms3 := msize(f3); // 返回array(3,2,2)
// -msize(t,1) 返回二维数组，每个维度的下标集合，第一行记录第一维，第二行记录第二维，依此类推
ms11 := msize(f1, 1); // 返回array((0,1,2,3))
ms21 := msize(f2, 1); // 返回array((0,1),(0,1))
ms31 := msize(f3, 1); // 返回array((0,1,2),(0,1),(0,1))
// -mrows(t) 功能同length
mr1 := mrows(f1); // 返回4
mr2 := mrows(f2); // 返回2
mr3 := mrows(f3); // 返回3
// -mrows(t,1) 返回一维数组，第一维度的下标集合
mr11 := mrows(f1, 1); // 返回array(0,1,2,3)
mr21 := mrows(f2, 1); // 返回array(0,1)
mr31 := mrows(f3, 1); // 返回array(0,1,2)
// -mcols(t) 返回整数，返回第二维的长度
mc1 := mcols(f1); // 返回0，一维数组没有第二维度
mc2 := mcols(f2); // 返回2
mc3 := mcols(f3); // 返回2
// -mcols(t,1) 返回一维数组，第二维度的下标集合
mc11 := mcols(f1, 1); // 返回array()，一维数组没有第二维度
mc21 := mcols(f2, 1); // 返回array(0,1)
mc31 := mcols(f3, 1); // 返回array(0,1)
// SetLength-重置矩阵的行数
f1 := Minit(3, 5, 1); // 3*5，值为1的矩阵
SetLength(f1, 10); // 重新设置f1的行数为10
return f1; // 大小变更为10*4，扩大的地方用0补充
// 返回：10*4矩阵。

除此之外，还有 Getintindexs,getstrindexs,getallindexs 等获取数组下标的模型也支持 FMArray，

但由于 FMArray 下标是从 0 开始的顺序下标，不存在自定义或字符串的下标，所以其中 getstrindexs 是没必要使用，而 Getintindexs、getallindexs 功能与 msize 等存在重合，因此，对于 fmarray 而言只需用 msize 来获得全部维度和维度的大小信息。

矩阵查找与遍历

运算符要点说明

Mfind、::、: := 和 mrow, mcol, mcell, mindex, mIndexCount 等矩阵运算符也支持对 fmarray 类型的计算。

其中：

Mfind、::、: := 可以遍历 fmarray 的全部维度
// 在用到 Mfind、::、::=进行遍历时，还可以用以下关键字对矩阵进行操作：

Mrow 可以获得第一维下标

Mcol 获得第二维下标

Mcell 获得遍历的当前单元格的值

Mindex(dim)可以获得指定的维度的下标，dim 从 0 开始，即 0 为第一维度。

mIndexCount 可以获得当前维度数

Mcell 赋值或者::=不能改变 fmarray 的类型

由于 FMArray 的各单元格类型是一致的，因此，与普通矩阵在赋值不同类型数据时存在差异。

Mcell 允许在遍历中赋值，但赋值的类型会被强制为 FMARRAY 固定的单元格类型。

如：

A := minit(2, 3, 1); // 初始化一个2*3的值为1的整数数组
A: := 99.99; // 将A矩阵中每个单元格的值都赋值为99.99，等同于 A:: mcell := 99.99;
// 最终A的单元格都是99，而不是99.99，因为fmarray的类型是整型，不会发生变化。
return A;

Mfind 中的替换以及 A[0, 1] := 99.99 等的赋值都是如此。

查找与遍历举例

MFind 可以查找矩阵中的符合条件的位置以及值，还可以替换符合条件的值。

:: 矩阵遍历算符，功能类似于 for 循环，支持语句段。

: := 即矩阵遍历赋值算符，不支持语句段，一般当某函数只支持数值计算，不支持数组计算时，可通过此方式快速实现。

一般而言，优先使用 Mfind，效率较高。

####### Mfind 应用举例

// 数据样本
f1 := fmarray[1, 2, 0, 4, 5]; // 一维
f2 := fmarray[[1.1, -2.0], [0.0, 8.5]]; // 2*2
// MFind(t)返回单元格中为真的项的下标,二维数组，一行存放一个值的下标
mf1 := MFind(f1); // 返回array((0),(1),(3),(4))
mf2 := MFind(f2); // 返回array((0,0),(0,1),(1,1))
// MFind(t,exp)返回单元格中符合条件的项的下标
mf3 := MFind(f1, mcell >= 2); // 返回array((1),(3),(4))
mf4 := MFind(f2, mcell >= 2); // array((1,1))
// MFind(t,exp,RetV)返回符合条件的下标和值，二维数组，最后一列是单元值，前面的是下标
mf5 := MFind(f1, mcell >= 2, 1); // array((1,2),(3,4),(4,5))
mf6 := MFind(f2, mcell >= 2, 1); // array((1,1,8.5))
// MFind(t,exp,RetV,v); 替换符合条件的值，并返回,返回结果同MFind(t,exp,RetV)
mf7 := MFind(f1, mcell >= 2, 1, 100); // 将值大于等于2的单元格赋值为100
mf8 := MFind(f2, mcell >= 2, 0, 100.); // 将值大于等于2的单元格赋值为100.
// 此时f1，f2的结果分别为：
// 多维数组同样也支持，用法一样，此处只挑一种用法进行举例
f3 := fmarray[[[1, 1], [2, 0]], [[1, 2], [0, -3]], [[3, 8], [-8, 10]]];
mf := MFind(f3, Mcell < 0, 1, 0); // 将多维矩阵中小于0的值用0替代，并返回符合条件的下标与原值
// 此时，f3的值为fmarray[[[1,1],[2,0]],[[1,2],[0,0]],[[3,8],[0,10]]]
return mf;

返回 mf 如下：

####### ::与::=的应用举例

范例 01：将随机矩阵中，行列标相同的单元格的值赋值为 1

// 方法一：::的实现
F1 := mrand(5, 4);
F1::mcell := mrow = mcol?1:mcell;
return F1;
// 方法二：::=的实现
F2 := mrand(5, 4);
F2: := mrow = mcol?1:mcell;
return F2;

F1 与 F2 的返回结果如下：

范例 02：统计多维矩阵中第三维度中每个序列中小于 0.5 的数量

// ::的实现
F1 := mrand(5, 4, 10); // 三维
A := MInit(5, 4, 0); // 记录结果
F1::begin
    A[mrow][mcol] += mcell < 0.5;
end;
return A;

范例 03：::=实现数值函数的批量操作一般的数值函数都已实现对数组的支持，可以直接使用，比如 FloatN，既可以对数值 12.656 进行四舍五入，也能对数组 array(12.656,11.121)或 fmarray[12.256,11.121]进行四舍五入。但也可能存在部分函数在设计时没考虑到数组的情景，或用户自己在封装时没有考虑数组的情景，此时，则可借助::=运算来快速实现对数组的支持。比如，RoundTo5 函数只能.5 处理一个实数，那我们想要处理矩阵中每个单元格中的数值则可通过 t::= RoundTo5(mcell)来快速实现，实现如下：

F := fmarray[6.3, 5.6, 3.1, 4.2, 5.25];
F: := RoundTo5(mcell);
return F;

子矩阵的提取与赋值

FMArray 支持 array 子矩阵操作的所有形式。

子矩阵提取

以下均假设 A 是一个矩阵。

数组取数是使用[]运算符，FMArray 矩阵也如此。

例如 A[2,3]表示行下标为 2 列下标为 3 的值。相对于其它方式，有降维效果。

N:M 的方式可以取矩阵的下标连续的子集。

例如 A[2:5]表示取 A 矩阵行下标为 2 到 5 之间的子矩阵。

A[2:5][0:1] 表示取 A 矩阵行下标为 2 到 5 之间，列下标为 0 到 1 之间的子矩阵。

多维矩阵依此类推。

当该维度需要取所有下标时，可以用 : 来表示全部，比如 A[:][0:1] 表示取所有行，而列为 0 到 1 之间的子矩阵。

Array(N,M,…)的方式可以取矩阵任意下标集合的子集。

例如 A[array(2,5,6)]表示取 A 矩阵中行下标为 2、5、6 的三行组成的矩阵。

A[array(2,5,6), array(0,2)] 表示取 A 矩阵中行下标为 2、5、6，列下标为 0 和 2 的新矩阵。

以上几种方式可以混搭灵活使用，能满足各类子矩阵提取的需求。

fm := mrand(3, 4, 5);

fm[:,0,:]为固定维度 1 下标为 0 的二维矩阵

fm[:,array(2,3),:] 用数组做下标取多个下标

fm[:,2:3,:] 用 fromindex:toindex 模式取多个下标

子矩阵赋值

子矩阵提取后可以直接赋值，值可以是一个简单类型的值或行数相同的一维矩阵，也可以是一个与子矩阵结构一致的矩阵。

注：子矩阵赋值后不能改变原矩阵的单元格数据类型。

// 比如，A[0,1]:=100，即可以将矩阵 A 的行下标为 0，列下标为 1 的单元格赋值为 100。
A[2:5] := 100，可以将矩阵 A 的行下标从 2 到 5 的子矩阵的单元格的值都赋值为 100。

赋的值也是一个矩阵的具体案例如下：

例 01：行数相同的一维矩阵，给同一行内的单元格赋相同的值。

f := fmarray[[11, 12], [31, 4], [5, 5]]; // 3*2矩阵
f[0:1] := array(100, 200); // 赋值为2行的一维数组，也可以是FMArray[100,200]
return f;

返回：即相同行的值一致，不同行不一样。

例 02：相同结构的矩阵

t := MInit(4, 3, 0);
t[1:2][0:1] := fmarray[[1, 10], [2, 20]]; // 子矩阵为2行2列，所以赋值的矩阵也需要是2行2列
return t;

行的自扩张

FMArray 支持行的自扩张，但不支持其他维度的自扩张。

// 比如，初始化一个 3 行 2 列的矩阵：A:=minit(3,2,0.0);
// 而后赋值：A[100]:=1;

即此时的 A 的大小变成了 101 行 2 列的矩阵，自扩张产生的中间值用 0 补充。

例如：

f := fmarray[1, 2, 3]; // 3行
f[10] := 10; // 赋值下标为10的行的值为10，此时的f会进行自扩张
return f;

返回：(可以看出自扩张的地方是用 0 在补充)

同样也支持对多维数组的行进行自扩张。

比如：

f := fmarray[[[1.5, 2.2], [1.6, 1.0]], [[1.4, -1.1], [-0.4, 2.]]]; // f的大小为2*2*2
f[10] := 10;
return f; // 此时的f大小为11*2*2，单元格数据类型依旧是浮点数

矩阵运算

支持矩阵运算的基础算符，也全部支持 FMArray 矩阵的计算。具体可参考天软帮助文档中的矩阵运算章节。

运算符

TSL 的基础算符有比如+,-,*,/,,%,mod,div,^,~,.=,.>,.<,.<>,.>=,.<=,.!,.&,.|,.^,.||,.&&,.!!,like,++,--等等。

矩阵运算符包括 :*, :/, :\\, :^, !, |, :|, union, ::, ::=, -> 等。支持全部矩阵计算算符

a := fmarray[1, 2, 3] + fmarray[2, 3, 4];

A 的结果为：fmarray[3, 5, 7]。

a := fmarray[1, 2, 3] + 1;

A 的结果为：fmarray[2, 3, 4]。

矩阵运算支持和 array 的混合运算

计算的结果类型和左值相同

也就是 fmarray :* array -> fmarray

  array :* fmarray -> array

a := fmarray[1, 2, 3] + array(2, 3, 4);

A 的结果为：fmarray[3, 5, 7]。

多维矩阵的转置

对超过 2 维矩阵的转置，fmarray 的矩阵和 array 不一样，fmarray 是对所有维度进行倒置，也就是说如果存在一个 1234 的四维矩阵，会转置为一个 4321 的矩阵。

如果要当成二维转置，请采用 mswap(fm,0,1)的模式，这样交换第 0 维和第 1 维的下标

Mswap

范例

// 将3*2*1的三维矩阵转换成2*3*1的矩阵
f3 := fmarray[[[1], [2]], [[1], [0]], [[3], [-8]]];
t1 := mswap(f3, 0, 1);
// t1的结果为fmarray[[[1],[1],[3]],[[2],[0],[-8]]]，是一个2*3*1的矩阵，只转换了第一维与第二维
// 用转置符进行转置
t2 := `f3;
// t2的结果为fmarray[[[1,1,3],[2,0,-8]]]是一个1*2*3的矩阵，是对所有维度的倒置

集合运算

Fmarray 支持集合运算

Union2,intersect,outersect,minus 都支持

集合运算支持和 array 的混合运算

计算的结果的数据类型和左值相同

即 fmarray union2 array -> fmarray

  array union2 fmarray -> array

如果合并操作的结果类型为 fmarray，fmarray 的单元格类型是能包容左右操作数单元格的类型

表现如下：

整数矩阵和浮点矩阵的操作是浮点矩阵

整数矩阵和 64 位整型矩阵的操作是 64 位整型矩阵

64 位整型矩阵和浮点矩阵的操作是浮点矩阵

注：多维矩阵做集合运算时，维度必须一致，且除第一维度的长度可以不相同外，其余维度的长度必须相同。

范例 01：矩阵集合并操（union2：将两个集合中的元素的合集去重后的结果）

f1 := fmarray[1, 2, 0, 4, 5];
f2 := fmarray[1, 0, 7];
t := f1 union2 f2;

t 的值为：fmarray[1,2,0,4,5,7]; 有去重效果

范例 02：Fmarray 与 array 做并操作

f1 := fmarray[1, 2, 0, 4, 5];
f2 := array(1, 0, 7.2);
t1 := f1 union2 f2;
t2 := f2 unon2 f1;

t1 的结果为：fmarray[1.0,2.0,0.0,4.0,5.0,7.2]，可以看出矩阵中单元格类型为浮点数。

t2 的结果为：array(1,0,7.2,1,2,0,4,5)

范例 03：二维矩阵的并操作

f1 := fmarray[[1, 2], [0, 4], [5, 6]];
f2 := array((1, 2), (3, 3));
return f1 union2 f2;

返回结果如下：（Fmarray 矩阵）

还支持多矩阵合并，如 f1 union2 f2 union2 f3 等操作。

其它集运算用法同 union2。更多功能介绍请查看该关键字的帮助说明。

矩阵连接

Fmarray 支持矩阵连接运算：

Union,|,:|的矩阵连接算符都支持

Union 与 union2 的区别在于，union 没有去重功能，就是把两个表的行连接起来。

连接运算支持和 array 的混合运算

计算的结果类型和左值相同

如果值为 fmarray，fmarray 的单元格类型是能包容左右操作数单元格的类型

例如整数矩阵和浮点矩阵的操作是浮点矩阵

注意点：由于 fmarray 属于固定列数的，在 union 的时候，如果右操作数的列多于左边，将会出错。

对于|,:|而言，如果右操作数行数少于左边，可以支持，少的行补 0，如果行数大于左边，则等于先将矩阵扩大再操作

由于 fmarray 属于完全矩阵，因而|,:|在操作的时候，当右操作数行数超过左边，两者的表现完全一致。这一点和 array 不同，因为 array 的本身行原本所具备的列数是不确定的，所以:|补齐列，而|不补齐。对于 fmarray 而言，列数是固定的，所以在这种行数不同的时候两者会具有一定的差异。

与 Array 的混合运算的表现与集合运算的表现一样，这里就不再重复举例，可参考上一章节的案例。这里就|与:|操作时，左右行数不一样的表现进行举例，如下：

例 1：矩阵行列相同时做|操作

t1 := fmarray[[1, 2], [3, 4], [5, 5]];
t2 := fmarray[[3, 4], [7, 8], [6, 9]];
t := t1 |t2;
return t;

返回：（将两个表的列连接起来）

例 2：左右两表行数不一致时的连接表现

t1 := fmarray[[1, 2], [3, 4], [5, 5]];
t2 := fmarray[[3, 4]];

则左表行数超过右表时，即 return t1|t2; 返回表现如下：右表少的地方用 0 补足

若右表行数超过左表时，即 return t2|t1;返回如下：是左表先自扩张同右表一致，而后进行拼接

同时，将上列中的|变更为:|效果也一样，在 FMArray 中，两者功能无区别。

SQL 语法对 FMArray 的支持

FMArray 支持 SQL 语法的大多数功能，但是由于这类语法操作不属于矩阵计算等高性能功能，因而用此类方式操作 FMArray 矩阵效率不高，用户要尽量避免使用。

Select 对 fmarray 的支持

允许对 fmarray 进行 select，但返回值目前不支持产生 fmarray，而是以前支持的 array 和 Matrix。

如果要产生的结果为 fmarray，需要对结果使用 arraytofm 进行转换。

说明：由于 select 允许指定列名，且计算值会不定，且 select 不属于矩阵计算等高性能功能，因而设计上并未支持返回结果集为 fmarray。

f1 := fmarray[[1, 2], [0, 4], [1, 2], [5, 6]];
t := select \ * from f1 end;

此时的 t 是一个 Array，而 select 改成 Mselect 后结果是一个 Matrix。

其它功能与用法与 Array 一致。

Insert 对 fmarray 的支持

允许 Insert 将 fmarray 或者 array 类型插入到 fmarray 之后

插入后结果还是 fmarray 矩阵，以及其他维度的结构和原矩阵单元格数据类型不会进行改变。

当插入的数据列数少于原有 fmarray，缺省的列设置为 0。

当插入的数据类型不同，会将数据转换到原 fmarray 的类型。如果类型不正确，例如送入字符串，会报错

当插入的维度少于原始维度，会填充插入数据的最后一个维度的数据到被插入的 fmarray 里

a := minit(2, 3, 1.0); insert into a array(9);

A 的结果是： fmarray1.0,1.0,1.0],[1.0,1.0,1.0],[9.0,9.0,9.0

Delete 和 update 对 fmarray 的支持

Delete 和 update 支持对 fmarray 的操作，操作后的结果还是一个 FMArray，且不会改变原矩阵单元格的数据类型。

例如：delete from f where [1]=4; 可以删除矩阵 f 中 1 列值为 4 的所在行；

update f set [0]=100 where [1]=4

end; 可以将 1 列中值为 4 的行的 0 列值更新为 100。

提示：fmarray 无法像 array 一样自动通过 update 增加列，这是因为这种操作对于 fmarray 相比 array 而言更慢，采用 fmarray 应该规避这类操作，只将 fmarray 用于必要的地方。

Fmarray 为 CopyOnwrite 模式

即当访问 Fmarray 矩阵时，只是引用，并不会产生复制操作，所以不会增大运行内存，只有当对矩阵进行写入时才会产生数据的复制。

如下这些操作，都只是引用：

A := minit(100, 100, 0.0);
B := a[0:98];
C := a[0];
D := A;

其内存表现：

支持 FMArray 的公用函数

常用支持 Array 数字数组的函数，也支持 FMArray 矩阵。

重构函数

支持 reshape，允许重新构造相同大小维度不同的矩阵

注意：在重构时元素的个数要与原个数保持一致

例如：

f1 := fmarray[[1, 2], [3, 4], [5, 5]];
t := Reshape(f1, 6);
return t;
// t 的值为 fmarray[1,2,3,4,5,5]; 即由一个 2\*3 的矩阵变成了一个 6 行的一维矩阵。

排序

Sortarray,sorttablebyfield 支持对 fmarray 的排序

Sortarray 支持一维的 fmarray

Sorttablebyfield 支持二维的 fmarray

范例 01：一维排序

f := fmarray[10, 2, -3, 8];
sortarray(f);
return f;

f 排序后的值为：fmarray[-3,2,8,10]

范例 02：二维排序

f1 := fmarray[[11, 12], [31, 4], [5, 5]];
SortTableByField(f1, 0, 1); // 按第一列进行升序排列
return f1;

All 与 Any

All、Any，模式与 array 同，如果用于行列的 any 返回值为 fmarray

原有数字类型函数

原有支持 array 的基础函数，所有数字类型的函数均支持

例如 abs,roundto 等等。

暂时未对基础函数的返回类型是字符串的进行支持，因为 fmarray 目前并不支持字符串，亦未做自动 array 类型的实现。

例如 floattostr(mrand(3))会报错

原统计函数

统计函数，均支持 fmarray，无论是单序列的函数双序列的

但如果多多维度的 fmarray 进行统计，本身返回不是一个标量的时候，我们并不返回相应的 fmarray 类型，而是返回 array 类型。

例如：

sum(minit(3,4,1.0))得到的数据是 array(3.0,3.0,3.0,3.0)

Sum(minit(3,4,1.0),1)对行统计得到的数据是 array(4.0,4.0,4.0)

这样设计为了兼容统计类函数的特殊返回值等设计，因为 fmarray 本身只支持数字类型

不支持的要点提示

1 不支持 Reindex,ReindexCopy 对 Fmarray 进行结构的操作。

无法对 fmarray 进行 reindex 操作，因为 fmarray 固定结构的特殊性，对这种操作的支持将会获得极差的性能，违背 fmarray 的初衷。

2 Fmarray 支持 DeleteIndex ,但不支持 DeleteField

提示：fmarray 的特殊结构导致删除列的操作相对 ARRAY 会极为缓慢，采用 fmarray 应该规避这类操作，只将 fmarray 用于必要的地方。

SQL 基础到 TS-SQL

SQL 基础到 TS-SQL 简介

SQL 的全称为 Structured Query Language，亦即结构化查询语言，顾名思义，SQL 本身就是一门计算机语言。目前，绝大多数的数据库系统的查询是基于 SQL 的，SQL 语言在数据处理和查询方面具有独特的优势。目前市面上流行的 SQL 主要有 SQLSERVER 支持的 T-SQL(Transact-SQL)以及 Oracle 支持的 PL/SQL(Procedural Language/SQL)，目前绝大多数的 SQL 都是基于 SQL-92 规范为蓝本建立起来（SQL-92 规范也就是 1992 年由多家数据库厂商一起建立的一个 SQL 的规范）。但需要注意的是，SQL 有规范但是却没有标准，每一家数据库厂商自己均提供自己的 SQL 实现，而且都有自己的 SQL 特性，所以也在很多方面互不兼容，兼容是为了移植，而不兼容处才体现出各自之优越。

SQL 对数据的处理除了查询以外，还支持数据删除，数据更新，数据插入等功能。

TSL 语言内置集成了类 SQL 语法。为什么说是类 SQL 语法呢？首先 SQL 作为一门独立的语言，和 TSL 语言的语法在相当多的地方有冲突，不可能对 SQL 语法不做改动就融入 TSL 语言，其次 TSL 语言的类 SQL 语法是在吸收 SQL 语法的精华的同时，还增加许多自身特色，例如支持时间序列分析，同时支持数据库以及 TSL 的内存表和天软数据仓库。此外，TSL 的 SQL 语法还支持对按照规范编写的对象进行查询，修改，插入和删除等工作。

无独有偶，微软的 Visual Studio 2008 里的 C#也引入了类 SQL 语法，微软称之为 LINQ – Language INtegrated Query，亦即语言集成查询。在我们的 TSL 中，类 SQL 语法我们称之为 TS-SQL(TinySoft SQL)。

注：与前面所学的相比，可能这个章节所讲述的内容会更易懂并且功能也更强大而且有时候会给人一个误解：SQL 无所不能。事实上，由于 SQL 是一门语言，所以 SQL 确实也是无所不能的，但是 SQL 有其局限性，在适合于 SQL 来实现的时候，无论运算效率还是简洁度而言都无以伦比，但在不适合于 SQL 来实现的时候，如果强行使用 SQL 语法来实现，可能既晦涩难懂，运行效率也非常低下。有许多程序员，已经沦为了数据库的奴隶，基本上最熟悉的就是 SQL 和数据库，在过分依赖 SQL 的时候，同时也给了自己的思想套上了一把枷锁，脱离了 SQL 就什么都不会了，所以笔者认为，无论 SQL 有多么强大，至少也需要知道自己如何去实现 SQL 实现的功能，可 SQL，亦可不。在许多情况下，尤其应该自己尝试实现去替代和超越适合于 SQL 的功能，不仅仅对于学习大有裨益，在今后的开发道路上，也会更为宽广，我们会尝试在后面做一些类似的尝试。

此外，SQL 主要适合处理的是以行为单位的数据，而矩阵计算等数学运算功能是不适合的，当然利用 SQL 进行组合亦可以实现许多类似的功能，作为探索，这值得嘉许。在开发的学习过程中，尤其鼓励使用一个不适合的东西去实现一个难以实现的东西，因为这往往可以锻炼人的异向思维能力。

事实上，TSL 语言本身内置了矩阵的计算的功能，在其他章节也会提到，而且矩阵计算事实上是可以以行、列、单元格为单位的，所以矩阵计算的支撑部分甚至于不亚于整套 SQL 的语法体系。而在面对越来越高级的语法，面对越来越强大的功能的时候，往往一两行可以解决许多问题，读者应冷静去思考其实现的途径，因为这些实现也是通过一行行最简单的代码来完成的。

SQL 语言本身就可以是一门相当复杂的课程，笔者希望可以抛弃掉许多专业的术语尽量简化理解，尝试用 TS-SQL 一步步带读者进入 SQL 的大门，并让读者了解到 SQL 和 TS-SQL 之间的差异以及 TS-SQL 和其他 SQL 相比的过人之处。但由于 SQL 本身的复杂性，本书的篇幅所限，不能一一展开，因此我们还是推荐对 SQL 很不熟悉的读者在阅读本章节之后可以再阅读专门的 SQL 语言相关的书籍。

TS-SQL 语法

SELECT 查询语句

TSL 语言支持 SELECT 语句，该语法类似于 SQL 中的 SELECT 语句，但是又有许多特色和差异。TSL 语言的 SELECT 语句既可以查询存贮在天软数据仓库中的基本面信息数据，也可以查询天软数据仓库中的交易定周期数据以及交易明细数据。除此以外，SELECT 语句还可以用来直接查询内存数组，以及对 SQL 的结果集进行后查询处理，并且，还支持对按照规范编写的对象进行查询。

与 SQL 不同，TSL 的 SELECT 查询语法由 SELECT 开始，END 结束。Select 中可以使用任何 TSL 函数，默认返回为一个二维数组。

与 SQL 不同，TSL 对字段的访问必需采用[字段名]的模式来表达,[]内可以是任何返回为数字或字符串的表达式，例如字段 close 用["close"]访问。

与 SQL 不同，TSL 的 SELECT 查询不支持 TOP N，但是支持更加灵活的 DRANGE(begn to endn)以及 M Of N 的模式来取指定的结果范围。

与 SQL 不同，在使用 JOIN 进行多表连接时，需要使用[1].[字段名]模式来访问指定的表列，而非“表名.字段”的模式。

与 SQL 不同，由于 TSL 支持(作为注释符号，因此 SQL 中的 count(),CheckSum()的模式在 TSL 的 SELECT 语句中用添加在（和之间的空格符号如：countof( _ )、countof()、CheckSumOf( _ )替代。

与 SQL 不同，TSL 的聚集函数为了和其他的函数分别开来，基本上在 SQL 的聚集函数的基础上添加 of，例如 count 对应为 countof，avg 对应于 avgof,sum 对应于 sumof 等等。

具体语法如下：

From 子句[SelectOpt(Options)] [distinct] [drange( <begntoendn | M Of N>)]

<select_list>  <from 子句> [where 子句] [group by 子句] [order by 子句] end;

为了方便使用和节省内存加快速度，TSL 语言还支持 SSELECT,MSELECT 和 VSELECT 三个关键字做 SELECT 查询，当使用 MSELECT 查询的时候，返回的结果类型为 Matrix 类型，当使用 VSELECT 的时候，直接可返回数据的值，当使用 SSELECT 的时候，返回结果为一个一维数组。

VSelect

VSelect 返回单个值，主要用于如 sumof、countof 这类统计中，其他功能与 Select 同，只是 Select 返回的结果一般为二维数组。

当需要返回某个字段的最大值的时候，采用 (select maxof( ["F1"] ) from table end)[0]["Expr1"] 来描述太复杂，而采用 VSelect maxof(["F1"] from table end 就可以直接返回最大值。

如：

t := zeros(10, "A");
t[:, "A"] := 1 -  > 10;
v1 := select sumof(["A"]) from t end;
v2 := vselect sumof(["A"]) from t end;

其中，v1 的结果为：array(("Expr1":55.0)),要得到 55 这个数值，需要进一步：v1[0,"Expr1"]

v2 的结果为：55

SSelect

SSelect 返回一个一维数组,例如只返回其中一列而且要一个一维向量，其它与 Select 一样，只是 Select 返回为一个二维数组。

SSelect 可用于对返回结果进行降维处理，用法如 sselect [“A”] from t end;

与 Select 的对比：

t := zeros(10, array("A", "B"));
t[:, "A"] := 1 -  > 10;
v1 := select ["A"] from t end;
v2 := sselect ["A"] from t end;

v1 与 v2 结果对比：

MSelect

MSelect 与 Select 几乎完全一样，只是 Select 返回结果是 Array 类型，而 MSelect 返回的结果内容为 Matrix，而 Matrix 类型是一个在内存中紧缩存贮的二维表结构，可以最大限度的节省内存空间。

用法同 select，如：

t := zeros(10, array("A", "B"));
t[:, "A"] := 1 -  > 10;
return Mselect * from t end;

Select 子句

语法

SELECT [SELECTOPT(Options)] [DISTINCT][DRANGE(<begn to endn | M Of N>)]< select_list >

< select_list > ::=

{* | StartFieldIndex To EndFieldIndex |{ ［column_name］ | Expression}[ [ AS ] column_alias ]}[ ,...n ]

参数

####### SELECTOPT(Options)

指定 SELECT 的选项，控制 SELECT 的行为， Options 为以下数值的组合(以下数值的_XOR 或者相加)

下表中二进制位从 0 开始，可通过 2^N（2 的 N 次方）形式获取该位设置的值。

同时设置多模式时，可通过相加方式得到，比如设置 selectopt 的值为 2^6+2^8，则表示在使用 MovingFirst 模式的同时设置 refof 越界时返回 nil 而非 0（可参考下面示例 03）。

SelectOpt 以位掩码表示可选行为，常见选项：

SELECT_OPT_MULTIAGGSAMENAME（bit 4, value 16）：聚集字段名保持与字段一致。
SELECT_OPT_AGGSAMENAME（bit 5, value 32）：SUMOF(["abc"]) 返回字段名仍为 abc。
SELECT_OPT_N_LEAD_COND（bit 6, value 64）：MovingFirst 模式。
SELECT_OPT_DUP_FIELD_POS_TO_LAST（bit 7, value 128）：重复字段以最后一次为准。
SELECT_OPT_REFOF_EMPTY_NIL（bit 8, value 256）：refof 越界返回 nil。
SELECT_OPT_ORDERBY_REFOF（bit 14, value 16384）：ORDER BY 后以排序结果集为基准。
SELECT_OPT_NO_FAST_MOVING（bit 16, value 65536）：禁用移动计算的快速聚集算法（如 productof 等）。
SELECT_OPT_FAST_MOVING（bit 17, value 131072）：显式启用移动计算的快速聚集算法。
SELECT_OPT_NO_MOVING_FIRST（bit 18, value 262144）：显式关闭 MovingFirst 模式。

其余选项与完整列表请参考函数库与 TS-SQL 相关文档。

注：

1、关于 MovingFirst 模式与禁用移动计算时的快速计算模式位设置互相矛盾时

由于指定功能是与指定功能否是通过不同值进行的设置，因此在设置时可能同时存在，即出现位互相矛盾的情况时，则为 MovingFirst 为真的模式。

即若既设定 16 位也设定了第 17 位，或者设定了第 6 位也设定了 18 位，则依旧按照旧有真假模式，MovingFirst 为真。

范例：

示例 01：将表格行列下标更改为增长的自然数字下标数组

t := Zeros(4, array('A', 'B', 'C', 'D'));
return select selectopt(8) * from t end;

示例 02：对数组每列进行累加，累加后列名与原列名保持一致

t := `array('A': 0 -> 5, 'B': 10 -> 15, 'C': 20 -> 25);
return select selectopt(16) sumof(*, 1, 6) from t end;

示例 03：对数组进行分组后其它所有列求和

即除分组标识列后，其它所有列进行累加，累加后列名与原列名保持一致

实现：对数据 t 按第 0 列的值进行分组后，其它列分别相加求和

t := array(
("股票1", 100, 300),
("股票2", 1000, 200),
("股票3", 10000, 14),
("股票2", 100, 200),
("股票3", 10, 140),
("股票4", 100, 15));
return select selectopt(16) sumof( * ), [0] from t group by [0] order by [0] end;

注：上述实现中 selectopt(16) sumof( * )是在分组后，对所有列进行求和，由于 0 列不需要求和，因此取原始该列的值进行最后覆盖，保留原始值，达到目的。

示例 04：多功能模式展示，设置 selectopt 的值为 2^6+2^8，则表示在使用 MovingFirst 模式的同时设置 refof 越界时返回 nil 而非 0。

t := Integer(Rand(20, "v") * 100);
return select
selectopt(2 ^ 6 + 2 ^ 8)
* ,
sumof(["v"], ["v"] > 30, 2) as"sumV",
refof(["v"], 5, ["v"] > 30) as"ref5"
from t end;

####### DISTINCT

指定在结果集中只能显示唯一行。为了 DISTINCT 关键字的用途，空值被认为相等。不指定 DISTINCT 则指定在结果集中可以显示重复行。

####### DRANGE（begn TO endn）

指定只从查询结果集中输出从 begn 到 endn 之间的行。当 begn 到 endn 是 0 或者正整数的时候，位置偏移从第一条开始算，第一条位置为 0，当为负数的时候，偏移从最后一条开始算，最后一条的偏移为-1，倒数第二条为-2，以此类推。

如果查询包含 ORDER BY 子句，将输出由 ORDER BY 子句排序的从 begn 到 endn 之间的行。如果查询没有 ORDER BY 子句，行的顺序将由数据的存贮原有次序决定。

例子:

A := array();
for i := 0 to 999 do A[i]["ABCD"] := i;
return select Drange(10 to 99) * from A end;

返回序号为 10 到 99 的数据。

如果要返回的数据在后边的 10 条，那么

return select Drange(-10 to - 1) \ * from A end;

也就是说 DRANGE 里的范围为负数表示如下：

-1 为最后一条数据，-10 是倒数第十条数据。

####### DRANGE(M OF N)

指定只从查询结果集中输出从 (M-1)/N _ 记录总条数到 M/N _ 记录总条数 -1 之间的行。例如 DRange(5 Of 100)的意思是返回内容 100 等分的第 5 个等分，DRange(1 of 2)则返回前一半的内容。

如果查询包含 ORDER BY 子句，将输出由 ORDER BY 子句排序的 N 等分的第 M 等分的行。如果查询没有 ORDER BY 子句，行的顺序将由数据的存贮原有次序决定。

例子：

return select Drange(1 of 10) \ * from A end;

这就是返回 10 等分中的第一等分部分。

####### < select_list >

为结果集选择的列。选择列表是以逗号分隔的一系列表达式。

*：指定在 FROM 子句内返回所有列。列按 FROM 子句所指定的内容返回，并按它们在指定的内容中的顺序返回。

StartFieldIndex To EndFieldIndex：指定返回第几列到第几列。

例如一个结果集有字段名为 "f1" "f2" "f3"

1 to 2就表示列"f2"和"f3"

[column_name]

如果返回的是指定的列名，则采用在列名字符串或者列整数下标表达式加[]来表达。

Expression

是[列名表达式]、常量、函数以及由运算符连接的[列名表达式]、常量和函数的任意组合，或者是子查询。

column_alias

是查询结果集内替换列名的可选名。例如，可以为名为 quantity 的列指定别名，如"Quantity"或"Quantity to Date"或"Qty"，列名也可以是数字。

别名还可用于为表达式结果指定名称，例如：

select AvgOf(["close"]) as"Average close"

FROM MarketTable datekey encodedate(2002,1,1) to encodedate(2002,12,31) of

"SZ000001"end;

column_alias_str 不可用于 ORDER BY 子句，WHERE、GROUP BY 或 HAVING 子句。

From 子句

语法

FROM { <table_source> } [ , ...n ]

<table_source> : :=
    <Expression | THISGROUP | INFOTABLE 基本面表 ID>
  | { <MARKETTABLE | TRADETABLE>
      [DateKey BegTime TO EndTime]
      [of <StockID | StockIDArray>]
    }
  | { <SQLTABLE | HUGESQLTABLE [KEEPNULL]> <SQL_Str> <of SQL_Alias> }
  | <joined_table>
  | <table_source> CROSS JOIN <table_source>

<joined_table> : := <table_source> <join_type> <table_source> <ONWithExp>
<join_type> : := [{ LEFT | RIGHT | FULL }] JOIN
<ONWithExp> : := ON <search_condition>
            | with (Expression[,...n] ON Expression[,...n])

参数

####### Expression

二维数组表达式，从内存表中查询。

####### Thisgroup

在上一个分组中的子结果集。

参见：THISGROUP

####### infotable id

如果从基本面数据表里查询，则用 infotable 表 ID。

详细使用可参考：

FAQ：INFOTABLE

####### markettable

提取时间序列数据表格的关键字，如取天软指定周期的行情数据等。

例如从分钟线，日线，周，月，季，年线中查询，则用 markettable,具体周期由系统参数确定。

具体用法可参考：FAQ：MARKETTABLE

####### tradetable

如果从交易明细取数据，则用 tradetable，当当时周期为交易明细的时候，用 MarketTable 等同于 TradeTable。

具体用法可参考：FAQ：TRADETABLE

####### DATEKEY begtime TO endtime

从 markettable 和 tradetable 取数据的时候，如果需要对时间进行约束的话，用 datekey 指定开始到截止的时间。

####### OF <StockID | StockIDArray>

从 InfoTable、markettable 和 tradetable 取数据的时候，必需指定查询的证券代码或者证券代码列表。

####### sqltable|hugesqltable[KeepNull]<sql_str> of <Sql_Alias>

从 SQL 数据源里取数据的时候，sql_str 是 SQL 的字符串，sql_alias 是 SQL 执行依赖的别名。

当数据集合特别庞大的时候，采用 hugesqltable 可以节省内存，但是速度可能会比 sqltable 慢很多。

有关数据库别名请参考：ExecSQL

######## KeepNULL

当有 KeepNull 标识的时候，返回的结果集中如果为 NULL 值，则为 NIL 值，否则结果用默认的字段类型值，例如字符串类型字段的默认值为""。

JOIN 语法

JOIN 用于对多表进行连接，可以是 JOIN，LEFT JOIN，RIGHT JOIN，FULL JOIN，CROSS JOIN。JOIN,LEFT JOIN,RIGHT JOIN,FULL JOIN 支持 ON 或者 WITH 条件约束。

####### JOIN

Join 运算符返回满足第一个（顶端）输入与第二个（底端）输入联接的每一行。

####### LEFT JOIN

Left Join 返回每个满足第一个（顶端）输入与第二个（底端）输入的联接的行。它还返回任何在第二个输入中没有匹配行的第一个输入中的行。第二个输入中的非匹配行作为空值(NIL)返回。

####### RIGHT JOIN

Right Join 运算符返回满足第二个（底端）输入与第一个（顶端）输入中的每个匹配行联接的每一行。它还返回第二个输入中在第一输入中没有匹配行的任何行，即与 (NIL) 联接。

####### FULL JOIN

Full Join 运算符从第一个（顶端）输入中与第二个（底端）输入相联接的行中返回每个满足条件的行。它还可以从下面的输入返回行：

在第二个输入中没有匹配项的第一个输入。

在第一个输入中没有匹配项的第二个输入。

不包含匹配值的输入将作为空值返回。

####### CROSS JOIN

Cross Join 运算符将第一个（顶端）输入中的每行与第二个（底端）输入中的每行联接在一起。

Cross Join 不允许带 On 或者 With 条件，Cross Join 也可以用“，”（逗号）来替代。

####### ON 条件

Join,Left Join,Right Join,Full Join 允许添加 On 的条件，用法范例：

select \ * from a join b on [1].["ID"] = [2].["ID"] and [1].["Type"] = [2].["Type"]
end;

ON 的用法和 SQL 规范类似，但 On 条件不做优化，如果要进行优化加速，建议采用 With On 条件。

####### WITH ON 条件

Join,Left Join,Right Join,Full Join 允许添加 With On 的条件，用法范例：

select \ * from a join b with([1].["ID"], [1].["Type"] ON [2].["ID"], [2].["Type"])
end;

WITH ON 是 TSL 语言类 SQL 的自有的扩展特性，With On 是为了解决 Join 的效率问题，ON 的两旁是两组表达式，每组表达式的表达式个数应该完全相同，with on 会利用两组表达式进行预运算，并建立快速索引，解决效率问题，一般来说 With On 的计算复杂度和 N+M 是一个量级，而 ON 条件的计算复杂度和 N*M 是一个量级（假定左右输入的数据集合的记录数分别为 N 和 M），在 N 和 M 比较大的时候，性能的差异可以体现得非常明显，达到几个数量级的差异。

但是，由于 WITH ON 有预运算和索引，目前还不支持超大数据结果集之间的运算，在那种情况下，仍然只能使用 ON 条件。

WHERE 子句

语法

[WHERE ]

含义

WHERE 指定查询结果集的条件

范例

select \ * from SampleTable where ["字段"] > 10 end;

GROUP BY 子句

语法

[GROUP BY <Expression[....,n]> [HAVING ]]

含义

GROUP BY 子句包含以下子句：

一个或多个自由聚合的表达式。通参见：字段的表达与返回

1、常是对分组列的引用,多个列或多个表达式用逗号分隔。

2、通常情况下，HAVING 子句与 GROUP BY 子句一起使用。

常用方式如：

t := array(
("证券":"SH600028", "行业":"采矿业", "涨幅(%)":-1.01),
("证券":"SH600030", "行业":"金融业", "涨幅(%)":0.07),
("证券":"SH601166", "行业":"金融业", "涨幅(%)":-1.6),
("证券":"SH601211", "行业":"金融业", "涨幅(%)":0.29),
("证券":"SH601225", "行业":"采矿业", "涨幅(%)":-0.49),
("证券":"SH601658", "行业":"金融业", "涨幅(%)":-1.62),
("证券":"SH601668", "行业":"建筑业", "涨幅(%)":1.16));
return select ["行业"], maxof(["涨幅(%)"]) as"最大涨幅"from t
group by ["行业"]
end;

返回每个行业个股最高涨幅，结果：

只要表达式中不包括聚合函数，就可通过该表达式分组。

例如，对 A 股股价进行聚类，返回聚类中股票个数大于 10 的聚类，得到每个聚类的股票个数以及平均价格：

return select GetStockPriceType() as"价格分类",
AvgOf(["close"]) as"平均价格", COUNTOF() as"个数"
from MarketTable
DateKey today() to today()
of GetBK("深证A股;上证A股")
group by GetStockPriceType() having COUNTOF() > 10
end;

GetStockPriceType 函数的定义如下：

function GetStockPriceType();
begin
    return
    ifthen(["close"] > 15, "高价股", ifthen(["close"] > 5, "中价股", "低价股"));
end;

THISGROUP

如果要查询分组的子结果集，可以使用子 select 查询语句对 thisgroup 进行子查询。

ThisGroup 不是一个数据，仅仅只是子数据集，必需用 SELECT 的 FROM 子句来访问

例如有列”证券”,”行业”,”涨幅(%)”的二维数组

t := array(
("证券":"SH600028", "行业":"采矿业", "涨幅(%)":-1.01),
("证券":"SH600030", "行业":"金融业", "涨幅(%)":0.07),
("证券":"SH601166", "行业":"金融业", "涨幅(%)":-1.6),
("证券":"SH601211", "行业":"金融业", "涨幅(%)":0.29),
("证券":"SH601225", "行业":"采矿业", "涨幅(%)":-0.49),
("证券":"SH601658", "行业":"金融业", "涨幅(%)":-1.62),
("证券":"SH601668", "行业":"建筑业", "涨幅(%)":1.16));
return select ["行业"], maxof(["涨幅(%)"]) as"最大涨幅"from t group by ["行业"] end;

这种写法熟悉 SQL 的都可以很了解，但是如何访问在[“涨幅(%)”]的最大值发生时候的[“证券”]的值呢？

ThisGroup 可以解决这个问题

return select ["行业"], mzf := maxof(["涨幅(%)"]) as"最大涨幅",
vselect ["证券"] from thisgroup where ["涨幅(%)"] = mzf end
as"最大涨幅券"
from t group by ["行业"] end;

当然用户也可以使用 select * from ThisGroup end 来得到分组的完全值

ORDER BY 子句

语法

[ORDER BY <Expression[desc|asc]>[,....n]]

含义

指定在 SELECT 语句返回的列中所使用的排序次序。

参数

Expression

排序的表达式，支持多个表达式排序，每个表达式之间用逗号分割。每个表达式之后允许用 DESC 或者 ASC 来标识排序的方向。

desc

逆序方法排序

asc

正序方法排序

字段的表达与返回

在 SQL 语句中，可以直接用字段名访问字段的值，在 TSL 中，必须用[字段名字符串表达式]来访问，例如一个字段名为 close，访问其则为["close"]。

并且，TSL 语言中的字段表达式中的字段名字符串是大小写相关的。

如果使用了 JOIN 导致一个 SQL 语句中有多表时，则用[TableSequence].[字段名]来访问，例如：[1].["close"]代码第一个表的 close 字段，如果有多表，并且不指定表序号，则返回的内容会从第一个表开始逐步查找。

例如

S := ”abcd”;

[S]表示字段 abcd,也可以采用[“abcd”]，是一样的含义。

select [S] from Table end; // 表示返回列abcd而不是列S

同样[0]表示数字字段 0;

A := Rand(1000, array(“ABCD”));
B := select * from A where [“ABCD”] > 0.5 order by [“ABCD”] end;
return B;

再如：

select [“aaa”] as “aaa100” from a end;

返回的内容的字段名可以用 AS 更名，不带 AS 则使用系统的缺省名，如果返回的本身仅仅只是一个[]，则为原始的字段名，否则使用”Expr1”,”Expr2”…来命令

如果再 SELECT 中希望临时进行计算又不希望将临时计算的结果返回到结果集中，可以使用 AS NIL 的模式,可参考：Select as nil 语法

行、行下标、行序号与行校验

ThisRow

返回在表里的当前行的数据值。

当 SELECT 对一维数组进行查询的时候，THISROW 就很重要，因为没有列可以用来返回结果。

当有多个表进行 Join 的时候，调用 ThisRow 应该用 ThisRow(TableIndex)来指定特定的表。

ThisRowIndex

返回在表里的当前行的行下标值。

对于数组、矩阵、SQL 表而言，该索引是绝对的位置，对于其他类型而言，是一个相对的位置，例如对于 TRADETABLE 而言，是该行在当天的明细序列编号。

在采用 ORDER BY 排序的时候，THISROWINDEX 可以返回行原来的位置。

当有多个表 Join 的时候，调用 ThisRowIndex 应该用 ThisRowIndex(TableIndex)来指定特定的表。

ThisOrder

在有 order by 的查询中 ThisOrder 可以获得行的自然排序序号

ChecksumOf

ThisRow
ThisRowIndex
ThisOrder
ChecksumOf

聚集函数

为了防止和 TSL 其他函数产生冲突，聚集函数一般都以 OF 结尾，例如平均值是 AVGOF，求和是 SumOf。

TSL 支持的 SQL 语法的聚集函数有如下几个特点：

1、支持条件聚集，即统计满足条件的记录，（一般为第一个可选参数），如统计某列值大于 0.5 的项的总和

t := Rand(10, array("A", "B"));
return select
sumof(["A"], ["A"] > 0.5)
from t end;

返回结果是一个一行一列的数值。

2、支持时间序列化进行 N 日移动统计，即统计每行前 N 行内满足条件的记录，（一般为第二个可选参数），如计算每行某列的最近 N 日的移动平均

t := Rand(10, array("A", "B"));
return select * ,
AvgOF(["A"], true, 3)
as"3日平均"from t end;

返回结果是在原数组上增加["3 日平均"]列，展示如下：

3、条件与移动的优先顺序可控，默认为先条件再移动，若需要先移动再条件(MovingFirst 模式)，可通过两种方式实现：

一种是通过指定参数（一般为第三个可选参数）为真，第二种是通过 select selectopt(64)进行指定，如：

t := `array("A":(1, 5, 4, 6, 8, 2, 9, 9, 5, 3));
t1 := select * ,
Sumof(["A"], ["A"] > 4, 3)
as"sumA1",
Sumof(["A"], ["A"] > 4, 3, 1)
as"sumA2"from t end;
t2 := select
selectopt(64)
* ,
Sumof(["A"], ["A"] > 4, 3)
as"sumA1"from t end;

其中 t1 结果是默认情况下，不指定与指定 MovingFirst 模式的对照，展示如下：(sumA1 为默认方式结果，sumA2 为指定 MovingFirst 模式的结果）

t2 的结果是通过 select selectopt(64)进行指定默认方式转为 MovingFirst 模式，使["sumA1"]结果变更为["sumA2"]

4、可以利用 REFOF 访问前几条的数据，如：

t := `array("A":(1, 5, 4, 6, 8, 2, 9, 9, 5, 3));
return select * ,
refof(["A"], 1)
as"上一个A值"from t end;

5、支持先排序后聚集，默认情况下是先聚集后排序，如果希望 refof 或者移动聚集函数使用排序后的序列而非结果集原始序列，可以在 TS-SQL 里使用 SelectOpt(16384)，具体参见:SELECTOPT(Options)。

6、 TSL 还支持多字段聚集返回

TSL还支持多字段聚集返回，例如AvgOf ( * )则一次返回每个字段聚集的结果，利用多字段聚集的时候，同样支持条件聚集，用AggValue可以返回当前聚集的字段的值。例如：AvgOf( *,AggValue>10)则表示求每个字段大于10的平均数。当然也可以用Avgof( *,AggValue>10,20) 来求符合的移动平均。

多字段聚集返回时可通过 SelectOpt(16)指定列名与聚集列的列名保持一致。

多字段聚集返回还支持部分多字段聚集返回，利用 AvgOf(0 to 2)就可以分别返回 0,1,2 字段的平均数。

如：

t := Rand(10, array("A", "B", "C", "D"));
t1 := select
Maxof( * )
from t end; // 返回每列中最大值
t2 := select
selectopt(16) Maxof( *
) from t end; // 返回每列中最大值，且列名与聚集列的列名保持一致
t3 := select
Maxof( * , AggValue < 0.5 )
from t end; // 统计每列中小于0.5的项的最大值
t4 := select
Maxof( 0 to 2, AggValue < 0.5 )
from t end; // 统计前3列中小于0.5的项的最大值

7、支持时序计算时增加缓存加速，默认不进行缓存加速，（一般为第四个可选参数），具体可参考：SQL 时间序列统计缓存标志与性能加速

多字段聚集

表达式可以用 * ，也可以用 StartFieldIndex To EndFieldIndex 如 0 to 2 的模式。

*表示每个字段进行聚集，0 to 2 表示第一个到第三个字段求聚集。SelectOpt 设置为 16 可以使得聚集的结果字段名和原始字段名一致。

例如，SumOf( * )可以对每个字段求和

SumOf(0 to 2)可以返回前三个字段的求和（返回三个求和值）

默认的情况下，SumOf( * )和 SumOf(N1 to N2)返回的结果会按照正常模式以 ExprN 作为字段返回，例如"Expr1","Expr2"…，如果设置了 SelectOpt(16)则可以以原始的字段名返回。例如:

a := array(("abc":1, "bcd":2), ("abc":2, "bcd":3));
b := select sumof( * ) from a end; // b的结果为array(("Expr1":3,"Expr2":5));
c := select selectopt(16) sumof( * ) from a end; // c的结果为array(("abc":3,"bcd":5));

多字段聚集的时候，如果需要参与运算，用 AggValue 可以访问到当前运算的字段值，例如 SumOf( *,AggValue>10)

COUNTOF

范例

范例 01：

Table1 := array(('A':1, 'B':2, 'C':7),
('A':nil, 'B':3, 'C':12),
('A':4, 'B':20, 'C':34));
return VSelect COUNTOF( * ) from Table1 end; // 返回组中项目的数量，包括NULL和副本
// 返回结果为：3

范例 02：

Table1 := array(('A':1, 'B':2, 'C':7),
('A':nil, 'B':3, 'C':12),
('A':4, 'B':20, 'C':34));
return VSelect COUNTOF( ['A'] ) from Table1 end; // 返回非空值的数量
// 返回结果为：2

REFOF

范例

范例 01：

Table1 := array(('A':5, 'B':1, 'C':34),
('A':6, 'B':2, 'C':34),
('A':3, 'B':4, 'C':34),
('A':2, 'B':2, 'C':34),
('A':7, 'B':8, 'C':34),
('A':-1, 'B':59, 'C':34),
('A':1, 'B':18, 'C':34),
('A':9, 'B':1, 'C':34),
('A':2, 'B':0, 'C':34),
('A':4, 'B':18, 'C':34));
return select ["A"], REFOF(["A"], 2, ['A'] > 2) as'refA'from Table1 end;

COUNTIFOF

范例

范例 01：

Table1 := array(('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34) );
return VSelect COUNTIFOF( ['A'] > 4 ) from Table1 end; // 返回[‘A’]>4的项目的数量
// 返回结果为：4

范例 02：

Table1 := array(('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34) );
return select COUNTIFOF(['A'] > 4 , 2) from Table1 end;

AVGOF

范例

范例 01：

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect AVGOF( DISTINCT ['A'] ) from Table1 end; // 返回6.

范例 02：

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34) );
return select AVGOF( ['A'], ['A'] > 4, 2 ) from Table1 end;

EMAOF

范例

范例 01：

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34) );
return select emaof(['A'], 1, 2) from Table1 end;

SMAOF

范例

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34) );
return select smaof(['A'], 2, 1, 3) from Table1 end;

HARMEANOF

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect HARMEANOF( DISTINCT ['A'] ) from Table1 end;
// 返回结果5.83333333333333

GEOMEANOF

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect GEOMEANOF ( DISTINCT ['A'] ) from Table1 end;
// 返回结果5.91607978309962

SUMOF

范例

范例 01：

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect SUMOF( DISTINCT ['A'] ) from Table1 end; // 返回结果12.

范例 02：

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34) );
return select SUMOF( ['A'], ['A'] > 4, 2 ) from Table1 end;

MINOF

范例

范例 01：

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect MINOF( ['A'], ['A'] > 6 ) from Table1 end; // 返回7

范例 02：缓存串范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect MINOF( ['A'], 1, nil, 1, '<MAXMIN=minA/>') from Table1 end;//返回5

MAXOF

范例

范例 01：

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect MAXOF( ['A'], ['A'] > 6 ) from Table1 end; // 返回9

范例 02：缓存串范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect MAXOF( ['A'], 1, nil, 1, '<MAXMIN=MAXA/>') from Table1 end;//返回9

RefMinOf

范例

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':2, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return select minof(['A'], 1, nil, 1, '<MAXMIN=minA/>'),
minof(['B'], 1, nil, 1, '<MAXMIN=minB/>'),
refminof(['B'], 'minA') , refminof(['A'], 'minB') from Table1 end;

RefMaxOf

范例

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':2, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return select maxof(['A'], 1, nil, 1, '<MAXMIN=maxA/>'),
maxof(['B'], 1, nil, 1, '<MAXMIN=maxB/>'),
refmaxof(['B'], 'maxA') , refmaxof(['A'], 'maxB') from Table1 end;

MODEOF

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect modeOF( ['A']) from Table1 end; // 返回5

MEDIANOF

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect MEDIANOF ( ['A']) from Table1 end; // 返回6

STDEVOF

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect STDEVOF( ['A']) from Table1 end;
// 返回结果1.91485421551268

STDEVPOF

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect STDEVPOF( ['A']) from Table1 end;
// 返回结果1.6583123951777

VarOf

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect VarOf ( ['A']) from Table1 end; // 返回结果3.66666666666667

VarpOf

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect VarpOf ( ['A']) from Table1 end; // 返回结果2.75

TotalVarOf

算法

其中，X 为样本数据，μ 为总体均值。范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect TotalVarOf ( ['A']) from Table1 end; // 返回结果11

AvedevOF

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect AvedevOF ( ['A']) from Table1 end; // 返回结果1.5

DEVSQOF

算法

其中，X 为样本数据，μ 为总体均值。范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect DEVSQOF ( ['A']) from Table1 end; // 返回结果11

NORMOF

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect NORMOF ( ['A']) from Table1 end; // 返回结果13.4164078649987

SKEWOF

算法

其中，s 是样本标准差范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect SKEWOF ( ['A']) from Table1 end; // 返回结果0.854563038327971

SKEW2OF

算法

其中，σ 为总体标准差范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect SKEW2OF ( ['A']) from Table1 end; // 返回结果0.493382200218159

KURTOSISOF

算法

其中，S 为样本的标准差。范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect KURTOSISOF ( ['A']) from Table1 end; // 返回结果-1.28925619834711

KURTOSIS2OF

算法

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect KURTOSIS2OF ( ['A']) from Table1 end; // 返回结果1.62809917355372

Largeof

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect largeof( ['A'], 2) from Table1 end; // 返回结果7

Smallof

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect Smallof ( ['A'], 2) from Table1 end; // 返回结果5

Percentileof

算法

对序列从小到大排序，数据长度为 n，则

（1）求(n-1)* K，记整数部分为 i，小数部分为 j

（2）所求结果＝（1－j）序列第(i ＋ 1)个数＋ j序列第(i+2)个数范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect Percentileof( ['A'], 1 / 3) from Table1 end; // 返回结果5

PercentRankOf

算法

1）对数组进行排序；

2）计算指定数值 X 所处的排序后的位置比例。即小于 X 的值的个数/(总个数-1)；

3）X 值不存在数据集中则使用线性插值法得到；范例

范例 1：一维数组中

x := array(10, 6, 2, 1, 9);
return vselect PercentRankOf(thisrow, 2) from x end; // 结果是0.25

范例 2：二维数组中，忽略空值

Table1 := array(
('A':2, 'B':3, 'C':7),
('A':10, 'B':1, 'C':5),
('B':1, 'C':5),
('A':6, 'B':8, 'C':4) );
return VSelect PercentRankOf( ['A'] , 6) from Table1 end; // 结果是0.5

注意：PercentRankOf 可只用于数字列。空值将被忽略。

该模型只适用于计算指定值在序列中的排名，不适用于批量计算每个值的排名百分位，大量排名计算时可参考：

FAQ：Q：计算序列中每个值的排位百分点的效率问题

QuartileOf

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect QuartileOf ( ['A'], 0) from Table1 end; // 返回结果5

RankOf

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect RankOf ( ['A'], 7) from Table1 end; // 返回结果2

TrimMeanOf

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return VSelect TrimMeanOf ( ['A'], 0.2) from Table1 end; // 返回结果6.5

FrequencyOf

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return vSelect FrequencyOf ( ['A'], array(6)) from Table1 end;

ProductOf

范例

Table1 := array(
('A':5, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return vSelect ProductOf ( ['A']) from Table1 end; // 结果1575

AGGVALUE

一般用于多字段聚集中，返回当前参与聚集的列的值。用法如 SUM( *,AggValue>10)。

示例：

t := Rand(10, array("A", "B", "C", "D"));
t1 := select selectopt(16) Maxof( * , AggValue < 0.5 ) from t end; // 统计每列中小于0.5的项的最大值
t2 := select selectopt(16) Maxof( 0 to 2, AggValue < 0.5 ) from t end; // 统计前3列中小于0.5的项的最大值

t1 与 t2 的结果展示：

其中，SelectOpt(16)使指定列名与聚集列的列名保持一致

CHECKSUM_AGGOF

范例

Table1 := array(
('A':6, 'B':20, 'C':34),
('A':5, 'B':20, 'C':34),
('A':9, 'B':2, 'C':34),
('A':2, 'B':20, 'C':34),
('A':7, 'B':18, 'C':34));
return vSelect CHECKSUM_AGGOf(['C']) as'CHECKSUM_AGGOf'from Table1 end;
// 返回1849359852

AGGOF

范例

Table1 := array(
('A':6, 'B':20, 'C':1),
('A':5, 'B':20, 'C':2),
('A':9, 'B':2, 'C':3),
('A':2, 'B':20, 'C':4),
('A':7, 'B':18, 'C':5));
return vSelect aggof('AggSumSample', ['C']) from Table1 end; // 返回结果15
// 自定义的AggSumSample聚集函数。
function AggSumSample(Flag, Value);
begin
    if FLag = 0 then
    begin
        SysParams['SumSample'] := 0;
        return true;
    end
    else if Flag = 1 then
    begin
        SysParams['SumSample'] := SysParams['SumSample'] + Value;
        return true;
    end
    else return SysParams['SumSample'];
end;

####### 聚集扩展函数的定义规范

function AggFunctionName(Flag:Integer;Value:[Boolean|Any]):[Boolean|Any];

说明

flag 的值表示调用该函数时的状态。

0：聚集的初始化

value 为真则是 DISTINCT，否则为所有。

返回为真表示成功，为假则失败。

1：行数据

value 为当前行的表达式执行的值。

返回为真表示成功，为假则失败。

2：聚集结束

返回聚集函数的执行结果。

范例：求和的聚集函数，其中利用系统参数来缓存数据。

function AggSumSample(Flag, Value);
begin
    if FLag = 0 then
    begin
        SysParams["SumSample"] := 0;
        return true;
    end
    else if Flag = 1 then
    begin
        SysParams["SumSample"] := SysParams["SumSample"] + Value;
        return true;
    end
    else return SysParams["SumSample"];
end;