csh/playbook
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9010829c6df1067c1960c5d492b0acd28242e4e4
playbook/skills/tsl-api-reference/references/codegen/dotnet.md
T
csh 9010829c6d ✨ feat(tsl-api-reference): expand and reorganize api catalog 
Flatten builtin pages, add third-party and platform scopes, and import financial and data warehouse references.

Keep the existing generated index without rebuilding after signature normalization.
2026-08-10 18:26:24 +08:00

13123 lines
453 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Dotnet
以下为 .NET 运行环境提供的函数。
## `accumulativeYtMtoYtm(t, fname, dw)`
声明：function
复合益率转日收益率。
| 参数 | 类型 | 说明 |
| ------- | ------- | ---------------------------------- |
| `t` | array | 数据表类型，复合收益率序列 |
| `fname` | string | 字符串，收益字段名称 |
| `dw` | integer | 整数，决定源数据的单位和返回的数据 |
返回：array
### 示例
```tsl
// 源数据单位为1,设dw=2,同时返回复合收益率和转换后的日收益率
t1 := array(('日期': 20180801T, '复合收益率': 0.1),
('日期': 20180802T, '复合收益率': 0.4),
('日期': 20180803T, '复合收益率': 0.7));
r1 := accumulativeYtMtoYtm(t1, '复合收益率', 2);
// 源数据单位为%,设dw=3,同时返回复合收益率和转换后的日收益率
t2 := array(('日期': 20180801T, '复合收益率(%)': 10),
('日期': 20180802T, '复合收益率(%)': 40),
('日期': 20180803T, '复合收益率(%)': 70));
r2 := accumulativeYtMtoYtm(t2, '复合收益率(%)', 3);
return r1|r2;
// 输出：返回：
```
## `Anova_Bartlett(y, alpha)`
声明：function
在1-alpha的置信水平下，Bartlett方法检验方差齐性；B-Stat为统计值，P-Value为p值，df为自由度，Hypothesis为是否接受原假设 模型表达： Bartlett检验思想来源于几何平均数小于或等于算术平均数 原假设：是水平个数 ,其中 修正的Bartlett检验：
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------------- |
| `y` | array | 数据矩阵，为二维数组类型，每一行表示一个水平 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Anova_Levene(y, alpha)`
声明：function
在1-Alpha的置信水平下，Levene方法检验方差齐性，和Bartlett检验不同的是，Levene检验不要求总体具有正态性。返回一个数组，F-Stat为统计值，P-Value为p值，df1，df2为自由度，Hypothesis为是否接受原假设 模型表达： 原假设：是水平个数 ，其中是观察数目，是水平数目
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------------- |
| `y` | array | 数据矩阵，为二维数组类型，每一行表示一个水平 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Anova_Single(y, alpha)`
声明：function
在1-alpha置信水平下，在假设服从正态分布，且方差齐性，样本之间独立的基础上，判断各水平的均值是否显著相等 模型表达： ， 其中：效应平方和：，误差平方和： 总离差
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------------- |
| `y` | array | 数据矩阵，为二维数组类型，每一行表示一个水平 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Anova_Twice(y, alpha)`
声明：function
在1-alpha的置信水平下，进行双因子方差分析，假设每一种情况都服从一个正态分布，且方差相等，数据独立，判断各水平的均值是否显著相等 模型表达： 有A，B两个因素，因素A有r个水平，B有s个水平，对于A，B每一个组合(Ai,Bj)都进行t次试验，得到结果： 因素B 因素A B1 B2 … Bs A1 X111, X112,…,X11t X121, X122,…,X12t … X1s1, X1s2,…,X1st A2 X211, X212,…, X21t X221, X222,…, X22t … X2s1, X2s2,…, X2st … … … … Ar Xr11, Xr12,…, Xr1t Xr21, Xr22,…, Xr2t … Xrs1, Xrs2,…, Xrst 设：且相互独立 ，其中，是水平Ai的效应，是水平Bj的效应，称为水平Ai和Bj的交互效应。， 原假设：，， 现构造了3个F统计量来分别检验假设，原理略
| 参数 | 类型 | 说明 |
| ------- | ----- | ----------------------------------------------------------------------------------------------- |
| `y` | array | 数据矩阵，为二维数组类型，每rep行，每一列表示一个交叉项 |
| `alpha` | float | 显著性水平，实数或整数，在01之间；Rep:每一个交叉项，做rep次试验，rep=1时，没有交叉效应为0的假设 |
返回：array
## `ar(y, p, approach)`
声明：function
自回归模型，AR(p)模型，选择使用最小二乘，Yule-Walker方法，Foiward-backward,Geometric lattice,Burg’s lattice-bas去估计p阶自回归模型的系数，返回结果有自回归系数、残差方差、预测值及预测波动等信息
| 参数 | 类型 | 说明 |
| ---------- | ------------- | ---------------------------------------- |
| `y` | array of real | 样本序列，为一维数组类型，注意要零均值化 |
| `p` | integer | 自回归阶数 |
| `approach` | string | 估计方法 |
返回：array
### 示例
```tsl
elps := randnorm(0, 1, 200);
y := array();
y[0] := 0;
y[1] := 0;
for i := 2 to 199 do
y[i] := -0.5 * y[i-1]+0.3 * y[i-2]+elps[i];
return ar(y, 2, 'ls');
```
## `arma(series, p, q)`
声明：function
自回归移动平均模型，ARMA(p,q)模型，采用逆函数去估计自回归系数和移动平均系数，返回结果有自回归系数、移动平均系数、残差方差等信息 ARMA模型： 其中：为原序列零均值化的新序列，是自回归方程系数，为移动平均系数，是零均值、方差为的平稳白噪声
| 参数 | 类型 | 说明 |
| -------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `series` | array | 样本序列，为一维数组类型，注意要零均值化 |
| `p` | int | 自回归阶数，整数类型 |
| `q` | int | 移动平均阶数，整数类型；返回结果:；Ret\["AR"\]:参数估计结果，，第一项为1；Ret\["MA"\]:参数估计结果，，第一项为1；Ret\["T-test"\]:AR模型参数的T检验；Ret\["LossFunction"\]；Ret\["FPE"\]:预测最大误差；Ret\["AIC"\]:模型的AIC信息准则；Ret\["SC"\]:模型的SC信息准则；Ret\["e"\]:残差信息；Ret\["Inverted AR Roots"\]:AR特征方程的特征根；Ret\["Inverted MA Roots"\]:MA特征方程的特征根；Ret\["R_squared"\]:AR模型的可决系数；Ret\["Adjusted_R_squared "\]:AR模型的修正可决系数；Ret\["Sum_squared_resid"\]:AR模型的离差平方和；Ret\["Durbin Watson stat"\]:DW统计量；Ret\["Log Likelihood"\]:对数极大似然值；Ret\["S.E. of regression"\]:回归标准差 |
返回：array
### 示例
```tsl
elps:=randnorm(0,1,200);
y:=array();
y[0]:=0;
for i:=1 to 199 do
y[i]:=0.8*y[i-1]+elps[i]-0.4*elps[i-1];
arma(y,1,1);
```
## `BarLine_Web(r, graph_title, return_type)`
声明：function
返回直方图。主要用于网页设计。
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------ |
| `r` | array | 数据表类型，数据； |
| `graph_title` | string | 字符串，图形标题； |
| `return_type` | any | 整数，返回类型。 |
返回：array
## `betaAndAlpha(y, x, beta, alpha)`
声明：function
得到斜率和截距。
| 参数 | 类型 | 说明 |
| ------- | ----- | ------------------ |
| `y` | array | 一维数字数组 |
| `x` | array | 一维数字数组 |
| `beta` | real | 实数，斜率，返回值 |
| `alpha` | real | 实数，截距，返回值 |
返回：void
### 示例
```tsl
betaAndAlpha(array(3, 6), array(4, 12), k, b);
return k;
// 返回：0.375
```
## `betainc(x, a, b, tail)`
声明：function
不完全贝塔函数
| 参数 | 类型 | 说明 |
| ------ | ------ | ------------------------------------- |
| `x` | array | (一维数字数组,实数) 变量 要求0<=x<=1; |
| `a` | float | float 不完全贝塔函数的参数 要求a>=0; |
| `b` | float | float 不完全贝塔函数的参数 要求b>=0; |
| `tail` | string | 返回类型 |
返回：array
### 示例
```tsl
a := 3;
b := 4;
tail := 'upper';
x := rand(10);
return array(betainc(x, a, b), betainc(x, a, b, tail));
```
## `binofit(x, n, alpha)`
声明：function
根据样本x，x服从二项分布，估计该分布的参数p
| 参数 | 类型 | 说明 |
| ------- | ------------- | ------------------------ |
| `x` | array of real | 二项分布样本，数字数组 |
| `n` | | 试验总量,为大于0的整数； |
| `alpha` | real | 显著性水平，在0-1之间 |
返回：any
### 示例
```tsl
x := randbino(10, 0.5, 1);
return binofit(x, 10, 0.05);
// 输出：返回p的估计以及在alpha的显著性水平下的区间估计
```
## `boxcox(y)`
声明：function
在做线性回归的过程中，不可观测的误差可能是和预测变量相关，于是给线性回归的最小二乘法估计系数的结果带来误差，为了解决这样的方差齐性问题，所以考虑对相应应变量做Box-Cox变换，变换之后，可以一定程度上减小不可观测的误差和预测变量的相关性
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------------------------- |
| `y` | array of real | 因变量序列，为一维数组类型 |
返回：array
### 示例
```tsl
data := rand(100);
return boxcox(data);
```
## `chol(h, l, p, options, sneg)`
声明：function
进行乔列斯基分解，H对称正定，则可以得到三角阵L
| 参数 | 类型 | 说明 |
| --------- | ------- | ------------------------------------------------------------ |
| `h` | array | 需要被分解的对称矩阵，正定矩阵的分解才能成功 |
| `l` | array | 变参返回乔列斯基分解得到的三角阵 |
| `p` | integer | 变参返回H的分解信息，-1表示全部分解成功，否则表示分解到第p步 |
| `options` | array | 三角阵选项，默认'upper'为上三角，'lower' 为下三角 |
| `sneg` | array | 当 H 非正定时计算曲率方向，正定时为空 |
返回：array
### 示例
```tsl
h := corr(rand(100, 4));
chol(h, l, p); // 乔列斯基分解
if p = -1 then return l; // p=-1表示分解成功
```
## `Cluster_Kmeans(samples, class_count, options)`
声明：function
执行 K-means 聚类。
| 参数 | 类型 | 说明 |
| ------------- | ----- | ------------------------------------------------------ |
| `samples` | array | 样本矩阵 |
| `class_count` | any | 聚类数量 |
| `options` | array | 参数表；常见键包括 `maxiter`、`tol`、`distance`、`out` |
返回：array
## `Cluster_System(a, dmethods, methods, options)`
声明：function
sample是一个样本数据观测矩阵，每一行是一个样本数据，本函数依据各种不同的距离对样本进行谱系聚类
| 参数 | 类型 | 说明 |
| ---------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `a` | array | 样本数据观测矩阵，每一行是一个样本数据 |
| `dmethods` | any | 整数或字符串类型，距离方式,参数的输入格式参考\[Distance\]name的输入,缺省欧式距离 |
| `methods` | any | 1:组间以中心距离,默认组间中心距离；2:以组间最短距离；3:以组间最大距离 |
| `options` | array | 默认为输出谱系树；Options\['best':1\]:输出最优分类；Options\['tree':1\]:输出谱系树，默认输出谱系关系；Options\['out':0\]:最佳分类排列方式。1每一行为一个类（默认）0各个样本对应的类 |
返回：array
## `Cluster_ward(samples)`
声明：function
执行 Ward 聚类。
| 参数 | 类型 | 说明 |
| --------- | ----- | -------- |
| `samples` | array | 样本矩阵 |
返回：array
## `componentMatrix(eigen_value, eigen_vector, max_eigen_value)`
声明：function
载荷矩阵
| 参数 | 类型 | 说明 |
| ----------------- | ----- | ------------------------------------ |
| `eigen_value` | array | 一维数字数组类型，特征根 |
| `eigen_vector` | array | 二维数字数组类型，特征向量 |
| `max_eigen_value` | array | 一维数字数组类型，主因子对应的特征根 |
返回：array
### 示例
```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
return componentMatrix(eigen_value, eigen_vector, max_eigen_value);
```
## `componentScoreMatrix(cm, r)`
声明：function
因子得分系数矩阵
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `cm` | array | 二维数字数组类型，载荷矩阵 |
| `r` | array | 二维数字数组类型，相关系数矩阵 |
返回：array
### 示例
```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
return componentScoreMatrix(cm, r);
```
## `cond(x)`
声明：function
求矩阵 X 的条件数，最大奇异值除最小奇异值
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------- |
| `x` | array | array 需要求条件数的矩阵或二维数组 |
返回：real
### 示例
```tsl
x := array((9, 1), (-1, 0), (0, 2), (1, 1));
return cond(x); // 4.22
```
## `corr(a, _type, tail)`
声明：function
计算相关系数矩阵及其检验P值
| 参数 | 类型 | 说明 |
| ------- | ------------- | ------------------------------------------------------------------------- |
| `a` | array of real | 样本数据观测矩阵，二维数字数组 |
| `_type` | integer | 1:pearson相关；2:Kendall等级相关；3:Spearman秩相关 |
| `tail` | string | 假设检验的三种类型，字符串，取值为both、left和right，缺省是只输出相关系数 |
返回：array
### 示例
```tsl
a := rand(3, 4);
return corr(a, 1); // 返回的是一般相关系数矩阵
// 输出：结果：
a := rand(3, 4);
return ret := corr(a, 1, 'both');
// 输出：结果：
array(
(
(1, -0.997183665009044, -0.25079062964811, 0.52903553507686),
(-0.997183665009044, 1, 0.177482907109564, -0.463902099303707),
(-0.25079062964811, 0.177482907109564, 1, -0.954156728736678),
(0.52903553507686, -0.463902099303707, -0.954156728736678, 0.999999999999999)),
(
(0.00, 0.0477902336084508, 0.83861889909013, 0.645107717271616),
(0.0477902336084508, 0.00, 0.886409132694126, 0.692897950958597),
(0.83861889909013, 0.886409132694126, 0.00, 0.1935111818216),
(0.645107717271616, 0.692897950958597, 0.1935111818216, 2.683151079097E-8)))
Ret[0]：相关系数矩阵
Ret[1]：相关系数假设检验P值
```
## `corr_canonical(x, y, alpha, standarize_choice)`
声明：function
典型相关分析，默认条件从中心化数据出发衡量两组随机变量之间的相关性
| 参数 | 类型 | 说明 |
| ------------------- | ----- | -------------------------------------------------------------- |
| `x` | array | X属性样本数据，二维数字数组，详见实例分析 |
| `y` | array | Y属性样本数据，二维数字数组，详见实例分析 |
| `alpha` | float | 置信度，实数型，0~1之间，缺省值0(不执行典型相关系数显著性检验) |
| `standarize_choice` | any | 原始数据标准化选择，整数型，0~7，缺省值为0(保持原始数据) |
返回：array
## `corr_Kendall(x_values, y_values)`
声明：function
计算 Kendall 秩相关系数。
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------- |
| `x_values` | array | 第一组数据 |
| `y_values` | array | 第二组数据 |
返回：float
## `Corr_partial(x, y, z, _type)`
声明：function
偏相关系数，返回x和y在控制变量z下的偏相关系数，行为样本，列为指标
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------------------------------------------------------------------------------- |
| `x` | array | 变量一，二维实数数组 |
| `y` | array | 变量二，二维实数数组 |
| `z` | array | 控制变量，二维实数数组 |
| `_type` | any | 1:pearson偏相关;2:Spearman偏相关；tail:假设检验的三种类型，字符串，取值为both、left和right，缺省是只输出相关系数 |
返回：any
## `corr_Spearman(x, y)`
声明：function
Spearman相关系数，简称斯皮尔曼相关系数，经常用希腊字母ρ表示。 它是衡量两个变量的依赖性的非参数指标。它利用单调方程评价两个统计变量的相关性。 如果数据中没有重复值，并且当两个变量完全单调相关时，斯皮尔曼相关系数则为+1或1。
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------- |
| `x` | array | 一维数组，随机变量x |
| `y` | array | 一维数组，随机变量y |
返回：float
## `corrcoef(a)`
声明：function
计算简单相关系数矩阵及其检验P值，以及简单相关系数置信区间的上下界（显著性水平为0.05）
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `a` | array,tablearray | 样本数据观测矩阵，二维数字数组返回结果:Ret["r"]:样本数据观测矩阵的简单相关系数矩阵Ret["p"]:检验相关系数是否显著的P值，二维数组Ret["rlo"]:简单相关系数置信区间的下界，二维数组Ret["rup"]:简单相关系数置信区间的上界，二维数组 |
返回：any
### 示例
```tsl
a := rand(7, 4);
return corrcoef(a); // 返回简单相关系数分析
// 输出：结果：
```
## `correlationMatrix(a1, t)`
声明：function
相关系数矩阵求解
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `a1` | array | |
| `t` | float | |
返回：array
### 示例
```tsl
a := rand(4,3);
correlationMatrix(a,1);
```
## `correlpaired(a, b)`
声明：function
功能：计算 a 的每一列与 b 的每一列之间的相关系数矩阵，
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------- |
| `a` | array | 一维数字数组, |
| `b` | array | 一维数字数组, |
返回：array
### 示例
范例01：
```tsl
a := array(1, 2, 3, 4, 5);
b := array(2, 4, 6, 8, 10);
return correlpaired(a, b);
// 输出：array((1.0))
```
范例02：
```tsl
a := array(1, 2, 3, 4, 5);
b := `array(
"B1": array(2, 4, 6, 8, 10),
"B2": array(10, 8, 6, 4, 2)
);
return correlpaired(a, b);
// 输出：array((1.0,-1.0))
```
范例03：
```tsl
a := `array(
"A1": array(1, 2, 3, 4, 5),
"A2": array(5, 4, 3, 2, 1)
);
b := `array(
"B1": array(2, 4, 6, 8, 10),
"B2": array(10, 8, 6, 4, 2),
"B3": array(1, 2, 3, 4, 5),
"B4": array(5, 4, 3, 2, 1)
);
return correlpaired(a, b);
// 输出：array((1.0,-1.0,1.0,-1.0),(-1.0,1.0,-1.0,1.0))
```
范例04：
```tsl
a := `array("A": array(1, 2, 3, 4, 5));
b := `array(
"A": array(2, 4, 6, 8, 10),
"B": array(10, 8, 6, 4, 2)
);
return correlpaired(a, b);
// 输出：array((1.0,-1.0))
```
## `correlpaired_side(a, dir_type)`
声明：function
功能：计算 a 的每两列之间符合对应过滤条件的相关系数矩阵， 1) +-相关系数 ：将 a <0 的元素替换为0 ，b>0的元素替换为0,计算相关系数 2) 同向相关系数 ：将 a 与 b 非同向（乘积<0）的元素替换为0，计算相关系数 场景支持同 correlpaired 内部强制 a 转化为fmarray进行计算
| 参数 | 类型 | 说明 |
| ---------- | ----- | ------------------- |
| `a` | array | 一维数字数组, |
| `dir_type` | any | 用户自定义,方向类型 |
返回：array
## `corrMatrixAdjust(a, adjust_type, n)`
声明：function
相关系数矩阵调整：将相关系数大或小的样本排在一起（重构）,输出结构调整，不改变相关系数本身
| 参数 | 类型 | 说明 |
| ------------- | ---------- | ------------------------------- |
| `a` | array | 二维数字数组，协方差矩阵 |
| `adjust_type` | userdefine | 用户自定义，调整方式，默认为0 |
| `n` | integer | 整数，分为N类，AdjustType=1专用 |
返回：array
### 示例
```tsl
a := corr(rand(6, 6));
return corrMatrixAdjust(a, 1, 5);
```
## `cov2CorrMatrix(a)`
声明：function
协方差矩阵转为相关系数矩阵
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------ |
| `a` | array | 二维数字数组，协方差矩阵 |
返回：array
### 示例
```tsl
a := covariance(rand(4, 3));
return cov2CorrMatrix(a);
```
## `covariance(a)`
声明：function
计算协方差矩阵
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `a` | array | |
返回：any
### 示例
```tsl
a := rand(4,3);
covariance(a);
```
## `det(a)`
声明：function
行列式
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------- |
| `a` | array | 二维数字数组 样本 |
返回：real
### 示例
```tsl
a := array((1, 2), (3, 4));
return det(a); // -2
```
## `diag(a)`
声明：function
对角阵
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `a` | array | array 数组 |
返回：array
### 示例
```tsl
a := array((2, 1), (1, 3));
return diag(a); // array(2,3);
```
## `discrim(a, x, method, options)`
声明：function
按照给定分类训练样本，根据训练结果对待定样本类别判定，也可作为原样本的回代检验
| 参数 | 类型 | 说明 |
| --------- | ------------- | ------------------------------------------------- |
| `a` | array of real | 样本数据观测矩阵，每行为一个样本，第0列为所在分类 |
| `x` | array of real | 样本数据观测矩阵，为待分类样本 |
| `method` | integer | 为判别方法，默认为 0 bayesian 判别，1为距离判别 |
| `options` | array | 为方法选项 |
返回：array
### 示例
```tsl
a := array(
(3.00, 8.35, 23.53, 7.51, 8.62, 17.42, 10.00, 1.04, 11.21),
(3.00, 9.25, 23.75, 6.61, 9.19, 17.77, 10.48, 1.72, 10.51),
(3.00, 8.19, 30.5, 4.72, 9.78, 16.28, 7.6, 2.52, 10.32),
(3.00, 7.73, 29.2, 5.42, 9.43, 19.29, 8.49, 2.52, 10.00),
(3.00, 9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(3.00, 9.16, 27.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(3.00, 10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81),
(1.00, 8.67, 36.05, 7.31, 7.75, 16.67, 11.68, 2.38, 12.88),
(1.00, 9.98, 37.69, 7.01, 8.94, 16.15, 11.08, 0.83, 11.67),
(1.00, 6.77, 38.69, 6.01, 8.82, 14.79, 11.44, 1.74, 13.23),
(1.00, 8.14, 37.75, 9.61, 8.49, 13.15, 9.76, 1.28, 11.28),
(1.00, 7.67, 35.71, 8.04, 8.31, 15.13, 7.67, 1.41, 13.25),
(1.00, 7.9, 39.77, 8.49, 12.94, 19.29, 11.05, 2.04, 13.29),
(1.00, 7.18, 40.91, 7.32, 8.94, 17.6, 12.75, 1.14, 14.8),
(1.00, 8.82, 33.7, 7.59, 10.98, 18.82, 14.73, 1.78, 10.1),
(1.00, 6.25, 35.02, 4.72, 6.28, 10.03, 7.15, 1.93, 10.39),
(2.00, 10.6, 52.41, 7.7, 9.98, 12.53, 11.7, 2.31, 14.69),
(3.00, 7.27, 52.65, 3.84, 9.16, 13.03, 15.26, 1.98, 14.57),
(3.00, 13.45, 55.85, 5.5, 7.45, 9.55, 9.52, 2.21, 16.3),
(3.00, 10.85, 44.68, 7.32, 14.51, 17.13, 12.08, 1.26, 11.57),
(3.00, 7.21, 45.79, 7.66, 10.36, 16.56, 12.86, 2.25, 11.69),
(3.00, 7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(2.00, 7.78, 48.44, 8.00, 20.51, 22.12, 15.73, 1.15, 16.61));
x := array(
(9.09, 28.12, 7.4, 9.62, 17.26, 11.12, 2.49, 12.65),
(9.41, 28.2, 5.77, 10.8, 16.36, 11.56, 1.53, 12.17),
(8.7, 28.12, 7.21, 10.53, 19.45, 13.3, 1.66, 11.96),
(6.93, 29.85, 4.54, 9.49, 16.62, 10.65, 1.88, 13.61));
options := array('cov': 1, 'backtest': 1, 'crosstest': 1);
return discrim(a, x, 0, options);
// 计算结果：
```
## `distance(x, y, name)`
声明：function
计算样本和样本间的距离或样本数据观测矩阵的距离矩阵，其中距离包括欧氏距离，欧氏距离平方，方差加权距离，Chebychev距离，Block距离，夹角余弦，广义距离
| 参数 | 类型 | 说明 |
| ------ | ------- | ---------------------------------------------- |
| `x` | array | 样本数据观测矩阵或样本数据，一维或二维数字数组 |
| `y` | array | 样本数据，一维数字数组 |
| `name` | integer | 距离方式，为一整数或字符串 |
返回：array
### 示例
```tsl
x := Array(22, 35, 24, 32, 43, 53);
y := Array(1, 2, 3, 4, 5, 6);
name := 'euclidean'; // 采用欧式距;
return distance(x, y, name);
// 输出：80.04998438475;
x := array(
(700.9, 39.77, 8.49, 12.94, 19.27, 11.05, 2.04, 13.29),
(7.68, 50.37, 11.35, 13.3, 19.25, 14.59, 2.75, 14.87),
(9.42, 27.93, 8.2, 8.14, 16.17, 9.42, 1.55, 9.76),
(9.16, 27000.98, 9.01, 9.32, 15.99, 9.1, 1.82, 11.35),
(10.06, 28.64, 10.52, 10.05, 16.18, 8.39, 1.96, 10.81));
name := "euclidean";
return distance(x, name);
// 输出：
array(
(0, 693.32, 691.62, 26970.08, 690.96),
(693.32, 0, 24.64, 26950.61, 23.54),
(691.62, 24.64, 0, 26973.05, 3.5),
(26970.08, 26950.61, 26973.05, 0, 26972.34),
(690.96, 23.54, 3.5, 26972.34, 0));
```
## `doubleVariableExecute(arr, sys_name, time_arr, exp)`
声明：function
计算指定系统参数，指定时间序列下的指标表达式的值
| 参数 | 类型 | 说明 |
| ---------- | ----------- | ---------------------------- |
| `arr` | integer | 二维数组，设置的系统参数的值 |
| `sys_name` | integer | 字符串，指定的系统参数名 |
| `time_arr` | integer | 二维数组，需要计算的指定时间 |
| `exp` | texpression | 表达式，指标表达式 |
返回：array
### 示例
```tsl
stocks := array(getBk('上证50'));
timer := marketTradeDayQk(20220101T, 20221211T);
return doubleVariableExecute(stocks, pn_Stock(), timer, @close());
// 返回: （部分结果截图）
```
## `eastrq(b, c, q)`
声明：function
Eastrq 相关函数。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `b` | array | 一维数字数组类型 |
| `c` | array | 一维数字数组类型 |
| `q` | array | 二维数字数组类型 |
返回：int
## `eigen(a, eigen, eigenvectors, isreal)`
声明：function
特征根与特征向量
| 参数 | 类型 | 说明 |
| -------------- | ------- | --------------------------------- |
| `a` | array | array 特征值分解的数据 |
| `eigen` | array | array 变参返回特征值 |
| `eigenvectors` | array | array 变参返回特征向量 |
| `isreal` | integer | bool 是否只输出实特征值及特征向量 |
返回：integer
### 示例
```tsl
a := array((1, 2), (3, 4));
eigen(a, eigen);
return eigen;
// array(-0.37,5.37)
```
## `Eigen_Jacobi(matrix, eigen_values, eigen_vectors)`
声明：function
用 Jacobi 方法计算矩阵特征值和特征向量。
| 参数 | 类型 | 说明 |
| --------------- | ----- | ---------------- |
| `matrix` | array | 待分解矩阵 |
| `eigen_values` | any | 接收特征值数组 |
| `eigen_vectors` | any | 接收特征向量矩阵 |
返回：void
## `Estimate_SND(x, alpha, tail)`
声明：function
在1-alpha置信水平下，求单个正态总体方差的置信区间（或下置信区间，上置信区间）
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------- |
| `x` | array | 样本序列，一维数组 |
| `alpha` | float | 显著性水平，实数，在0,1之间 |
| `tail` | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |
返回：array
## `Estimate_SNU(x, d, alpha, tail)`
声明：function
在1-alpha置信水平下，分为标准差未知和已知两种情况求单个正态总体均值的置信区间（或下置信区间，上置信区间）。
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------- |
| `x` | array | 样本序列，一维数组 |
| `d` | float | 正态总体的标准差，若未知，则输入nil，实数 |
| `alpha` | float | 显著性水平，实数，在0,1之间 |
| `tail` | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |
返回：array
## `Estimate_SP(mx, alpha, tail)`
声明：function
在1-alpha置信水平下，求比率或说概率的置信区间（或下置信区间，上置信区间）；
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------- |
| `mx` | float | 频率，实数；n;样本容量，整数 |
| `alpha` | float | 显著性水平,实数，在0,1之间 |
| `tail` | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |
返回：array
## `Estimate_TND(x, alpha, tail)`
声明：function
在1-alpha置信水平下，求两个正态总体方差之比的置信区间（或下置信区间，上置信区间）
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------- |
| `x` | array | 样本序列,含两行的二维数字数组，每行为一个样本 |
| `alpha` | float | 显著性水平,实数，在0,1之间 |
| `tail` | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |
返回：array
## `Estimate_TNU(x, d, alpha, tail, equal)`
声明：function
在1-alpha置信水平下，分为标准差未知和已知两种情况求两个正态总体均值差的置信区间（或下置信区间，上置信区间）;
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------------------ |
| `x` | array | 样本序列,含两行的二维数字数组，每行为一个样本 |
| `d` | array | 正态总体的标准差数组，若未知，则输入array(nil,nil)，为一维数组类型 |
| `alpha` | float | 显著性水平,实数，在0,1之间 |
| `tail` | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |
| `equal` | bool | 当标准差未知时，方差是否相等，布尔型 |
返回：array
## `Estimate_TP(p, alpha, tail)`
声明：function
在1-alpha置信水平下，求两个总体的比率或说概率差的置信区间（或下置信区间，上置信区间）
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------- |
| `p` | array | 频率数组；n;样本容量数组，一维数组 |
| `alpha` | float | 显著性水平,实数，在0,1之间 |
| `tail` | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |
返回：array
## `expdMax(r)`
声明：function
统计数组累计到当前行的最大值序列
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------------------------------------------ |
| `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |
返回：array
### 示例
```tsl
r := array(-1, 2, -3, 9);
return expdMax(r); // array(-1,2,2,9)
```
## `expdMin(r)`
声明：function
统计数组累积到当前行的最小值序列
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------------------------------------------ |
| `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |
返回：array
### 示例
```tsl
r := array(-1, 2, -3, 9);
return expdMin (r); // array(-1,-1,-3,-3)
```
## `expdProduct(r)`
声明：function
返回数组累积到当前行的累乘序列
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------------------------------------------ |
| `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |
返回：array
### 示例
```tsl
r := array(-1, 2, -3, 9);
return expdProduct (r); // array(-1,-2,6,54)
```
## `expdStd(r, ddof)`
声明：function
返回数组累积到当前行的标准差序列
| 参数 | 类型 | 说明 |
| ------ | ------------- | ------------------------------------------------------------ |
| `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |
| `ddof` | integer | 整型，标准差选项，取值如下 |
返回：array
### 示例
```tsl
r := array(-1, 2, -3, 9);
return expdStd (r, 0); // array(0,1.5,2.05,4.55)
```
## `expdSum(r)`
声明：function
返回数组累积到当前行的求和序列
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------------------------------------------ |
| `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |
返回：array
### 示例
```tsl
r := array(-1, 2, -3, 9);
return expdSum (r); // array(-1,1,-2,7)
```
## `expdVar(r, ddof)`
声明：function
返回数组累积到当前行的方差序列
| 参数 | 类型 | 说明 |
| ------ | ------------- | ------------------------------------------------------------ |
| `r` | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |
| `ddof` | integer | 整型，方差选项，取值如下 |
返回：array
### 示例
```tsl
r := array(-1, 2, -3, 9);
return expdVar (r, 0); // array(0,2.25,4.22,20.69)
```
## `expfit(x, alpha)`
声明：function
根据样本x，x服从指数分布，估计该分布的参数parm
| 参数 | 类型 | 说明 |
| ------- | ------------- | ---------------------- |
| `x` | array of real | 指数分布样本，数字数组 |
| `alpha` | real | 显著性水平，在0-1之间 |
返回：any
### 示例
```tsl
x := randexp(1, 100);
return expfit(x, 0.05);
// 输出：返回parm的估计已经他们的在alpha的显著性水平下的区间估计
```
## `exportCsvne(data, csv_str, include_index, include_header)`
声明：function
将指定数组Data转换为csv格式字符串并存储在csvStr参数中。仅支持一维及二维数组的转换。和ExportCsv的区别：在处理浮点数据时，ExportCsvne的结果不会输出为1E15等格式。
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ---- |
| `data` | array | |
| `csv_str` | string | |
| `include_index` | | |
| `include_header` | bool | |
返回：bool
### 示例
范例01：一维数组转换成csv格式字符串（含大数量级数据）
```tsl
data := array(1, 2, "3", "A", 9, 1E15);
ret := exportCsvne(data, s);
if ret then return s;
else return ret;
```
范例02：二维数组转换成csv格式字符串
```tsl
data := array((2, 5, 0), (3, 2, 1), (4, 7, 2));
ret := exportCsvne(data, s);
if ret then return s;
else return ret;
```
范例03：转换成csv格式字符串，结果包含数组下标信息
```tsl
data := array("A": (2, 5, 0), "B": (3, 2, 1), "C": (4, 7, 2));
ret := exportCsvne(data, s, 1);
if ret then return s;
else return ret;
```
范例04：转换成csv格式字符串，结果不包含字段头部信息
```tsl
data := array((2, 5, 0), (3, 2, 1), (4, 7, 2));
ret := exportCsvne(data, s, 0, 0);
if ret then return s;
else return ret;
```
## `exportFile2(_type, alias, file_name, data, include_header, include_index, sheet, range)`
声明：function
将数据导出到指定Sheet、指定数据位置Range的excel文件，仅支持Type类型为ftxls()的，为了兼容其他类型，如果输入的类型是非ftxls()的，则执行exportfile导出数据且无法指定Sheet和Range。注：导出时对应的excel文件需要关闭。
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ----------------------------------------------------------------- |
| `_type` | | 整数类型。参考导入导出类型函数。 |
| `alias` | string | 字符串类型。参考目录别名。 |
| `file_name` | string | 字符串类型。文件名称。 |
| `data` | | 数据，需要导出的数据。 |
| `include_header` | bool | 布尔类型。为真时导出的文件包含字段头部信息。缺省时候为真。 |
| `include_index` | bool | 布尔类型。为真时导出的文件包含数组下标信息。缺省时候为假。 |
| `sheet` | string | 字符串类型，指定Sheet。 |
| `range` | string | 字符串类型，指定单元格，如:”A1”表示要把数据导出到A1开始的单元格。 |
返回：integer|string
### 示例
```tsl
// 导出10 * 5全1矩阵，到C: \\test.xlsx 文件的Sheet3，C2单元格。
data := ones(10, 5);
ret := rdo2 exportFile2(ftXls(), "", "C:\\test.xlsx", data, 1, 0, "Sheet3", "C2");
return ret;
// 结果：1 (表示数据导出成功，可以在c盘看到test.xlsx文件)
```
## `factor(x, var_value)`
声明：function
对样本数据进行因子分析，分别采用主成分分析法估计因子载荷矩阵（因子载荷矩阵不唯一），方差最大法做载荷矩阵的正交旋转矩阵，回归方法计算因子得分
| 参数 | 类型 | 说明 |
| ----------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `x` | array | 二维维实数数组，表示样本矩阵； |
| `var_value` | float | 实数，表示方差贡献率,控制因子个数；；返回结果:ss；Ret\["Correlation Matrix",0\]:样本数据的相关系数矩阵；Ret\["kmo",0\]:KMO检验值；0.9<KMO: 非常适合；0.8<KMO<0.9:适合；0.7<KMO<0.8:一般； 0.6<KMO<0.7:适合度较低；KMO<0.6:适合度很低；ret\["Total Variance Explained",0\]:特征值、方差贡献率、累计方差贡献率等信息；ret\["Component Matrix",0\]:因子载荷矩阵；ret\["Communalities",0\]:共同变量度，即载荷矩阵行的平方和；ret\["thogonal matrix",0\]:正交变换后的载荷矩阵；ret\["Rotation matrix",0\]:旋转矩阵；ret\["Factor score",0\]:因子得分 |
返回：array
### 示例
```tsl
stockn:=getBk("上证A股");
vo:=BackUpSystemParameters();
setSysParam(pn_date(),today());
sto:=array();
for n_i:=0 to length(stockn)-1 do
begin
setSysParam(pn_stock(),stockn[n_i]);
if isStockGoMarket(intToDate(20011231)) then
sto[length(sto)]:=stockn[n_i];
end
st:=array2Str(sto,";");
a1:= query("",st,true,"","代码",defaultStockId(),
"主营业务利润",report(46008,20101231),
"利润总额",report(46024,20101231),
"净利润",report(46033,20101231),
"加权每股收益",report(42003,20101231),
"每股净资产",report(42006,20101231),
"加权净资产收益率",report(42013,20101231),
"资产总计",report(44059,20101231),
"股本",report(44099,20101231));
RestoreSystemParameters(vo);
a:=zeros(mrows(a1),mcols(a1));
a[:,:]:=a1[:,:];
stock:=a[:,0];
data:=a[:,1:8];
//取得纯数据矩阵
br:=factor(data,0.85); //
br;
```
## `factorScoreMatrix(cs, z)`
声明：function
主因子得分
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `cs` | array | 二维数字数组类型，因子得分矩阵 |
| `z` | array | 二维数字数组类型，原始数据矩阵 |
返回：array
### 示例
```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
cs := componentScoreMatrix(cm, r); // 因子得分矩阵
return factorScoreMatrix(cs, zt);
```
## `FastLine_Web(r, graph_title, data_prop, return_type)`
声明：function
返回线图或者数据，主要用于网页设计。
| 参数 | 类型 | 说明 |
| ------------- | ------ | ---------------------- |
| `r` | array | 一维数字数组，数据； |
| `graph_title` | string | 字符串，图形标题； |
| `data_prop` | array | 数据表类型，图形属性； |
| `return_type` | any | 整数，返回类型。 |
返回：array
## `filter_hp(y, l)`
声明：function
HP滤波法
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------- |
| `y` | array | 一维数字数组，时间序列 |
| `l` | any | 整数，平滑参数 |
返回：array
## `Fmin(fun, x0, a, b, aeq, beq, nonlcon, c)`
声明：function
（非线性规划建议统一使用prog_n函数），用起作用集法求任意形式非线性优化问题，结果返回最优点、最优值。可求解如下问题：
旧定义：`NonLP_Fmincon(Fun:String;X0:array;A:Array;B:Array;Aeq:Array;Beq:Array;Nonlcon:String):array`
来源：天软金融分析.NET函数大全 > TSL函数 > 数学函数 > 优化 > Prog_N
Source ID：21143
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun` | String | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型； |
| `a` | Array | 线性矩阵不等式约束，为二维数组类型； |
| `b` | Array | 线性向量不等式约束值，为一维数组类型； |
| `aeq` | Array | 线性矩阵等式约束，为二维数组类型； |
| `beq` | Array | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | String | 非线性约束回调，为字符串类型；nonlcon回调需用户自己新建一个函数，然后把函数名传进nonlcon，函数格式如下: Function “函数名”(x); Begin |
| `c` | | =array();// `_` C[0]:=…… C[1]:=…… …… Ceq:=array();// `_` Ceq[0]:=…… Ceq[1]:=…… …… Return array(0:c,1:ceq);// `*` End; // `*`号的式子一定要写 |
返回：array
## `fScoreResult(factor_arr, max_eigen_value)`
声明：function
获取主因子得分
| 参数 | 类型 | 说明 |
| ----------------- | ----- | ------------------------------------ |
| `factor_arr` | array | 二维数字数组类型，因子得分矩阵 |
| `max_eigen_value` | array | 二维数字数组类型，主因子对应的特征根 |
返回：array
### 示例
```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
cs := componentScoreMatrix(cm, r); // 因子得分系数矩阵
f_arr := factorScoreMatrix(cs, z_t_s); // 样本公共因子得分
return fScoreResult(f_arr, max_eigen_value);
```
## `ftCsVne()`
声明：function
逗号分割文件类型，输出结果禁用1E20等类型
返回：integer
## `garchFit(model_spec, y, x, e0, s0, y0)`
声明：function
广义自回归条件异方差模型，采用极大似然估计方法估计模型的参数
| 参数 | 类型 | 说明 |
| ------------ | ----- | ------------------------------------------------------ |
| `model_spec` | array | 模型设置项，为数据表类型，参考:表8-5 |
| `y` | array | 原始数据，一维数字数组 |
| `x` | array | 均值方程回归外生变量，二维数字数组，可缺省 |
| `e0` | array | 自回归方程残差序列起始的几项取值，一维数字数组，可缺省 |
| `s0` | array | 条件方程方差序列起始的几项取值，一维数字数组，可缺省 |
| `y0` | array | 原始序列起始的几项取值，一维数字数组，可缺省 |
返回：array
### 示例
```tsl
// 以1995年1月至2000年8月日元兑换美元汇率值序列（JPY，如图8-9）为例介绍怎样用天软来进行ARCH建模（序列共1427个值）。
// 图8-9日元兑换美元汇率值(JPY)序列图8-10DJPY时间序列
JPY序列显然是一个非平稳时间序列，对JPY进行差分，DJPY表示收益，见图8-10，因为DJPY是一个平稳时间序列，应该使用DJPY建立时间序列模型。按照ARMA模型中讲的那样对DJPY拟合ARMA模型，根据自相关系数以及偏自相关系数，AIC准则等，我们最终将模型定为AR(3)模型。
d_jpy := diff(jpy);
m := mean(d_jpy);
d_jpy := d_jpy-m;
ret := arma(d_jpy, 3, 0);
// 得到的结果是：
// 图8-11 AR(3)残差
// 该模型的残差如图8-11所示，我们怀疑残差含有异方差，使用Time_ARCHTest函数检验。
Time_ARCHTest(ret["e"], 1, 0.05);
// 图8-12 AR(3)残差
// 拒绝原假设，认为模型含有异方差，建立ARCH模型，首先建立ARCH(7)模型(尝试多次，最大滞后选为7为宜)。
// 图8-13ARCH模型结果图8-14异方差估计情况
modelspec := array(
("R": 3,
"M": 0,
"AR": nil,
"MA": nil,
"Regress": nil,
"VarianceModel": "GARCH",
"C": nan,
"P": 0,
"Q": 7,
"GARCH": array(),
"ARCH": array(),
"Leverage": nil));
t := garchFit(model_spec, d_jpy);
// 得到的异方差如图8-14。ARCH模型中的的滞后项太多，应该尝试建立GARCH(1, 1)模型：
modelspec := array(
("R": 3,
"M": 0,
"AR": nil,
"MA": nil,
"Regress": nil,
"VarianceModel": "GARCH",
"C": nan,
"P": 1,
"Q": 1,
"GARCH": array(),
"ARCH": array(),
"Leverage": nil));
t := garchFit(model_spec, d_jpy);
// 图8-15GARCH模型结果图8-16方差估计情况
```
## `generateCombinations(list, ret, start, n)`
声明：function
非空全组合生成器
| 参数 | 类型 | 说明 |
| ------- | ------- | --------------------------- |
| `list` | array | 一维数组 样本, |
| `ret` | array | 返回生成的组合数组, |
| `start` | integer | Int 选取起始数据的位置, |
| `n` | integer | Int 记录每组数据的起始位置, |
返回：integer
### 示例
```tsl
list := array('a', 'b', 'c');
generateCombinations(list, ret);
return ret;
```
## `getColorByIndex(index)`
声明：function
依据Index值，获得颜色数组内的指定颜色整数代号。
| 参数 | 类型 | 说明 |
| ------- | ------- | ---------------- |
| `index` | integer | 整数，颜色索引号 |
返回：integer
### 示例
```tsl
return getColorByIndex(1);
// 返回：16711680
```
## `getEigenValue(a, eigen_value)`
声明：function
通过赋值得到EigenValue
| 参数 | 类型 | 说明 |
| ------------- | ----- | ---------------- |
| `a` | array | 二维数字数组类型 |
| `eigen_value` | array | 一维数字数组类型 |
返回：any
## `GM_AGO(x, method, r)`
声明：function
数列生成，r(r>0)次的累加或累减生成新数列 1）累加：， 2）累减：，
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------- |
| `x` | array | 数据矩阵，为一维数组类型； |
| `method` | string | 生成方法(add,sub)，为字符串类型； |
| `r` | any | 次数，为整数类型 |
返回：array
## `GM_Corr(x, l)`
声明：function
灰色关联度，以l行为参考数列的灰色关联度，返回的是关联度矩阵 ，， 以为参考数列，则关联度计算步骤如下： 1）初值化：； 2）求差数列：， 3）求两级最大和最小：， 4）求关联系数：，为分辨系数，是0到1之间的数 5）求关联度：
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `x` | array | 数据矩阵，为二维数组类型； |
| `l` | any | 参考序列标号，为整数类型 |
返回：array
## `GM_Estimate(x, l)`
声明：function
GM(1,1)模型，用于灰色系统模型的l步预测 结果说明： 平均相对误差：越小越接近零越好； 关联度：当ρ=0.5时，关联度大于0.6便满意 方差比：C 小误差概率：P
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `x` | array | 数据矩阵，为一维数组类型； |
| `l` | any | 预测步长，为整数类型 |
返回：array
## `GM_Initial(x, method, un)`
声明：function
数据初始化，提供了几种数据变换的方法，有初值化、均值化、最小值化、最大值化、按行区间值化、按列区间值化、归一化、逆化、倒数化和始点零化处理原始的序列 1）初值化： 2）均值化：， 3）最小值化：， 4）最大值化：， 5）按行区间值化： 6）按列区间值化： 7）归一化：， 8）逆化： 9）倒数化： 10）始点零化：
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------------------------------------------- |
| `x` | array | 数据矩阵，为二维数组类型； |
| `method` | string | 处理方法(ini,mean,min,max,rrange,crange,norm,inv,rec,zero)，为字符串类型； |
| `un` | array | 归一化单位，为一维数组类型 |
返回：array
## `GM_Scorr(x, method)`
声明：function
灰色绝对关联度、灰色相对关联度和灰色综合关联度，返回的是关联度矩阵 ，， 1）灰色绝对关联度： 2）灰色相对关联度：先对数列进行初值化，然后求新数列的灰色绝对关联度，即为原数列的灰色相对关联度 3）灰色综合关联度：
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------- |
| `x` | array | 数据矩阵，为二维数组类型； |
| `method` | string | 方法(abs,ret,com)，为字符串类型； |
返回：array
## `H_J_CallBack(x, r)`
声明：function
H_J算法回调
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 一维数字数组类型 |
| `r` | float | 实数类型 |
返回：float
## `H_J_Method_Pgm(call_back)`
声明：function
H_J算法测试
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------------------- |
| `call_back` | string | 字符串类型，计算目标值的回调 |
返回：array
## `hessian(fun, x)`
声明：function
海塞矩阵 求解函数 fun 在x点的 海塞矩阵；
| 参数 | 类型 | 说明 |
| ----- | ------ | ---------------- |
| `fun` | string | 字符串，函数名 |
| `x` | array | 一维数组，指定点 |
返回：array
### 示例
```tsl
return hessian("Hessian.demo", array(3, 4));
```
## `hist(a, b, center)`
声明：function
统计A的频数分布
| 参数 | 类型 | 说明 |
| -------- | ------------------------ | ----------------------------------------------------------------------- |
| `a` | array of real | 参与进行频数分布统计的数据 |
| `b` | integer or array of real | 频数分布分组的依据,可以是整数表示分成多少组，也可以是每组的中心（升序） |
| `center` | array of real | 变参返回每组的中心 |
返回：any
### 示例
```tsl
a := randnorm(0, 1, 10000);
return hist(a, 30, center);
// 输出：，一维数字数组
```
## `histc(a, b)`
声明：function
端点定位频数，判断序列a 中各个元素在b中各个段位中的频数
| 参数 | 类型 | 说明 |
| ---- | ----- | -------- |
| `a` | array | 一维数组 |
| `b` | array | 一维数组 |
返回：array
### 示例
```tsl
a:=rand(1000)*5;
b:=array(0,1,2,3,4,5);
histc(a,b);
```
## `Hooke_Jeeves_Method(x0, d0, d_min, r, call_back)`
声明：function
H-J法求解无约束最优化问题
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------------------- |
| `x0` | array | 一维数字数组类型 |
| `d0` | array | 一维数字数组类型 |
| `d_min` | array | 一维数字数组类型 |
| `r` | float | 实数类型 |
| `call_back` | string | 字符串类型，计算目标值的回调 |
返回：array
## `Hypoth_IndepTest(x, alpha)`
声明：function
列联表检验法检验两个随机变量的独立性检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：H0:X 与Y 相互独立 检验统计量： 其中 ，，
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------- |
| `x` | array | 样本矩阵，为二维数组类型 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Hypoth_KruskalWallis(x, alpha)`
声明：function
两个或多个随机变量的独立性检验。本模型原假设为各随机变量相互独立。
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------- |
| `x` | array | 样本矩阵，为二维数组类型，每行为一个样本 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Hypoth_Kstest(data, tail, alpha, cdf)`
声明：function
在alpha的显著性水平下进行ks检验，检验序列是否服从cdf这种分布（缺省为标准正态分布），Hypothesis为测试结果,若Hypothesis=1,则认为服从;Hypothesis=0,可以认为不服从该分布
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data` | array | 样本数据，一维数字数组 |
| `tail` | string | 检验类型，字符串类型，必须包含在array("both","left","right")中 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
| `cdf` | array | 分布的累计概率分布，二维数字数组，第一列为随机变量，第二列为其对应的分布函数值，缺省为标准正态分布；返回结果:；ret\["statistical"\]:KS统计量；ret\["criticalValue"\]:KS检验的临界值；ret\["P-Value"\]:KS检验的P值；ret\["Hypothesis"\]:是否服从设定的分布 |
返回：array
## `Hypoth_lillietest(data, alpha, distr)`
声明：function
在alpha的显著性水平下进行lillietest检验，检验序列是否服从正态分布或对数分布（分布参数估计出来），Hypothesis为测试结果,若Hypothesis=1,则认为服从;Hypothesis=0,可以认为不服从该分布
| 参数 | 类型 | 说明 |
| ------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data` | array | 样本数据，一维数字数组 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
| `distr` | string | 分布函数类型，字符串数据，有"norm"、"exp"；返回结果:；ret\[""kstat"\]:统计量；ret\["cv"\]:检验统计量的临界值；ret\["P-Value"\]:检验的P值；ret\["Hypothesis"\]:是否服从设定的分布 |
返回：array
## `Hypoth_LSUTest(mx, s, n, u, tail, alpha)`
声明：function
单个或两个总体大样本的均值检验，即大样本U检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达 单个总体大样本的均值原假设：tail取值both：;left：;right： 两个总体大样本的均值假设：tail取值both：;left：;right： 检验统计量： 或 其中：x为样本x的均值，y为样本y的均值，为正态总体x方差，为正态总本y方差，m,n分别为样本x和y的容量s
| 参数 | 类型 | 说明 |
| ------- | ------ | ---------------------------------------------------------- |
| `mx` | array | 样本均值数组，第一行为样本1，第二行为样本2，为一维数组类型 |
| `s` | any | 样本方差数组，第一行为样本1，第二行为样本2，为一维数组类型 |
| `n` | array | 样本容量，第一行为样本1，第二行为样本2，为一维数组类型 |
| `u` | float | 单个总体时，为假设检验均值，两个总体时，为均值差 |
| `tail` | string | 假设检验类型 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Hypoth_McNemarTest(x, alpha)`
声明：function
非参数检验-McNemar检验。 对配对样本进行McNemar检验 McNemar检验以研究对象自身为对照，检验其两组样本变化是否显著 要求待检验的两组样本的观察值是二分类数据 检验统计量服从卡方分布
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------- |
| `x` | array | 样本统计列联表，为二维数字数组类型 |
| `alpha` | float | 显著性水平，在0-1之间，为实数类型 |
返回：array
## `Hypoth_PNUTest(samples, mean_diff, std_dev, tail, alpha)`
声明：function
执行配对样本均值差 U 检验。
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------------------------------- |
| `samples` | array | 两组配对样本数据 |
| `mean_diff` | float | 原假设均值差 |
| `std_dev` | float | 差值标准差；未知时传 `nil` |
| `tail` | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha` | float | 显著性水平 |
返回：array
## `Hypoth_PSignTest(x, pi, q0, tail, alpha)`
声明：function
非参数检验-配对样本符号检验,配对样本的符号检验 要求样本矩阵中两个样本是配对出现的 可以按照实际需求选择双侧或单侧检验
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------- |
| `x` | array | 一维数字数组,样本矩阵 |
| `pi` | float | 实数,分位点 |
| `q0` | float | 实数,检验值 |
| `tail` | string | 字符串,双侧检验 or 左侧检验 or 右侧检验 |
| `alpha` | float | 实数,显著性水平 |
返回：array
## `Hypoth_PWilcoxonTest(x, m0, tail, alpha)`
声明：function
非参数检验-配对样本Wilcoxon符号秩检验,配对样本的Wilcoxon符号秩检验 要求样本矩阵中两个样本是配对出现的 可以按照实际需求选择双侧或单侧检验
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------- |
| `x` | array | 一维数字数组,样本矩阵 |
| `m0` | float | 实数,检验值 |
| `tail` | string | 字符串,双侧检验 or 左侧检验 or 右侧检验 |
| `alpha` | float | 实数,显著性水平 |
返回：array
## `Hypoth_SignTest(x, pi, q0, tail, alpha)`
声明：function
非参数检验-符号检验。对单样本进行符号检验 可以按照实际需求选择双侧或单侧检验 其中，检验变量服从二项分布
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------------------------------------------------------- |
| `x` | array | 样本序列，为一维数字数组类型 |
| `pi` | float | 分位点，为实数类型 |
| `q0` | float | 检验值，即检验分位点的值，为实数类型 |
| `tail` | string | 假设检验的三种类型，both（双侧检验），left（左侧检验），right（右侧检验），为字符串类型 |
| `alpha` | float | 显著性水平，在0-1之间，为实数类型 |
返回：array
## `Hypoth_SNDTest(x, d2, tail, alpha)`
声明：function
单个正态总体方差的卡方检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：tail取值both：；left：；right： 检验统计量： 其中：为假设检验的方差，n为样本容量，s为样本标准差
| 参数 | 类型 | 说明 |
| ------- | ------ | -------------------------------- |
| `x` | array | 样本序列，为一维数组类型 |
| `d2` | float | 假设检验的方差，为实数类型 |
| `tail` | string | 假设检验类型 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Hypoth_SNUTest(x, u, d, tail, alpha)`
声明：function
单个正态总体的均值检验，分为标准差未知和已知两个情况，返回结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：tail取值both：；left：；right： 检验统计量：分为两种情况 1）标准差已知时，即d有取值，为U检验： 2）标准差未知时，即d取nil，为T检验： 其中：x为样本均值，为检验均值，为正态总体标准差，n为样本容量，s为样本标准差
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------------------- |
| `x` | array | 样本序列，为一维数组类型 |
| `u` | float | 假设检验均值，为实数类型 |
| `d` | float | 正态总体的标准差，为实数类型，若未知，则输入nil |
| `tail` | string | 假设检验的三种类型，字符串，取值为both、left和right |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Hypoth_TailRes(sta, v, tail, alpha)`
声明：function
根据tail的取值，进行单侧和双侧检验，原理是根据检验统计量计算P值，若alpha>p，则拒绝原假设，若alpha<p，则接受原假设；最后返回假设检验的结果。原假设分别是：
| 参数 | 类型 | 说明 |
| ------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `sta` | float | 统计量的值，为实数类型 |
| `v` | float | 整体分布的p分位数，1-v为检验的p值，为实数类型 |
| `tail` | string | 取值为both、left和right |
| `alpha` | float | 显著性水平，实数或整数，在0-1之间；返回结果:；ret\["Statistic"\]:假设检验统计量；ret\["P-Value "\]:假设检验的P值；ret\["Hypothesis "\]:是否接受原假设 |
返回：array
## `Hypoth_TNDTest(x, tail, alpha)`
声明：function
两个正态总体方差比的F检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：tail取值both：；left：；right： 检验统计量： 其中：Sx为x的样本标准差，Sy为y的样本标准差
| 参数 | 类型 | 说明 |
| ------- | ------ | ---------------------------------------------------------- |
| `x` | array | 样本序列矩阵，第一行为样本1，第二行为样本2，为二维数组类型 |
| `tail` | string | 假设检验类型 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Hypoth_TNUTest(x, uu, d, tail, alpha, isequal)`
声明：function
两个正态总体均值差的检验，分为标准差未知和已知两个情况，返回的结果是一个数组，第一个数为统计值，二为p值，三为是否接受原假设 模型表达： 原假设：tail取值both：；left：；right： 检验统计量： 标准差已知时，即d数组有取值，为u检验： 标准差未知时，即d取(nil,nil)，为t检验：， 其中：为样本x的均值，为样本y的均值，，为正态总体x，y的方差，分别为样本x和y的容量，为联合样本标准差
| 参数 | 类型 | 说明 |
| --------- | ------ | ------------------------------------------------------------- |
| `x` | array | 样本序列矩阵，为二维数组类型，第一行为样本1，第二行为样本2 |
| `uu` | float | 假设检验均值差，为实数类型 |
| `d` | float | 正态总体的标准差数组，为一维数组类型，若未知，则输入(nil,nil) |
| `tail` | string | 假设检验的三种类型，字符串，取值为both、left和right |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
| `isequal` | bool | object |
返回：array
## `Hypoth_WilcoxonTest(x, m0, tail, alpha)`
声明：function
非参数检验-Wilcoxon符号秩检验。单样本Wilcoxon符号秩检验 原理：把观测值和零假设的中心位置之差的绝对值的秩按照不同的符号相加作为其检验统计量。 此检验假定样本来自于连续对称总体。 计算步骤： 1、计算样本点到检验值的距离； 2、对上述距离的绝对值进行排序并计算秩，对相同的样本点则取平均秩； 3、分别计算大于检验值与小于检验值样本的秩和； 4、对得到的统计量计算p值
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------------------------------------------------------- |
| `x` | array | 样本序列，为一维数字数组类型 |
| `m0` | float | 检验值，为实数类型 |
| `tail` | string | 假设检验的三种类型，both（双侧检验），left（左侧检验），right（右侧检验），为字符串类型 |
| `alpha` | float | 显著性水平，在0-1之间，为实数类型 |
返回：array
## `ifThen3(left, right, r1, r2, r3)`
声明：function
比较left与Right大小，若Left大，则返回r1;若相等，返回r2;若Right大，返回r3。
| 参数 | 类型 | 说明 |
| ------- | ---- | ------ |
| `left` | real | 实数 |
| `right` | real | 实数 |
| `r1` | expr | 表达式 |
| `r2` | expr | 表达式 |
| `r3` | expr | 表达式 |
返回：expr
### 示例
```tsl
return ifThen3(1, 2, '左大', '相等', '右大');
// 返回：’右大’
```
## `importFile2(_type, alias, file_name, data, include_header, include_index, force_single, sheet, range)`
声明：function
导入excel中指定Sheet的内容，可选择指定数据范围Range。仅支持Type类型为ftxls()的，为了兼容其他类型，如果输入的类型是非ftxls()的，则执行importfile导入数据且无法指定数据位置Range。
| 参数 | 类型 | 说明 |
| ---------------- | ------- | ------------------------------------------------------------------------------------------------ |
| `_type` | integer | 整数类型。参考导入导出类型函数。 |
| `alias` | string | 字符串类型。参考目录别名。 |
| `file_name` | string | 字符串类型。文件名称。 |
| `data` | bool | 变参返回，存贮导入的数据。当导入成功的时候，数据将存放在Data。 |
| `include_header` | bool | 布尔类型。为真时认为导入的文件包含字段头部信息。缺省时候为真。 |
| `include_index` | bool | 布尔类型。为真时认为导入的文件包含数组下标信息。缺省时候为假。 |
| `force_single` | bool | 布尔类型。为真时认为导入的文件是一个一维数组。缺省时候为假。 |
| `sheet` | string | 字符串类型，指定Sheet。 |
| `range` | string | 字符串类型，指定单元格范围，如果为空导入Sheet的所有数据，非空则必须为excel的Range，如:“A1:E13“。 |
返回：bool
### 示例
```tsl
// 导入"C:\\test.xlsx"文件中的Sheet3的"C2:E5"数据，包含字段名称。
ret := rdo2 importFile2(ftXls(), "", "C:\\test.xlsx", data, 1, 0, 0, "Sheet3", "C2:E5");
if ret then
return data;
else
return "导入失败";
// 输出：
// 无输出。
// Excel的数据：
```
## `integral(call_back, a, b, method)`
声明：function
求函数的数值积分
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------- |
| `call_back` | string | 计算被积函数值的回调 |
| `a` | double | 实型变量。积分下限 |
| `b` | double | 实型变量。积分上限 |
| `method` | string | 积分方法 |
返回：double
### 示例
```tsl
a := 1;
b := 3;
callback := "fun1";
return integral(callback, a, b, ’romberg’);
// 其中fun1函数：
function fun1(x)
begin
return 2 * x+1;
end;
// 结果：10
```
## `interp(x, y, xi, method)`
声明：function
分段插值函数，根据给定的数据 x,y 对数据xv进行分段插值,可选择方法
| 参数 | 类型 | 说明 |
| -------- | ------------- | ------------------------------------------------------------- |
| `x` | array of real | 实型一维数组，长度为N。存放给定N个点的值Xi，要求X0<X1...<Xn-1 |
| `y` | array of real | 实型一维数组，长度为N。存放N个给定点上的函数值Yi |
| `xi` | array of real | 实数或者一维实数数组，存放指定插值点的值 |
| `method` | string | 方法选择，具体取值如下: |
返回：array
### 示例
```tsl
x := array(0, 0.01)->1;
y := x^2-x;
xi := array(0.005, 0.01)->1;
yi := interp(x, y, xi, 'spline');
return yi;
// 结果：6
1、"nearest"
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "nearest");
// 返回： array(2,7)
2、" linear" 分段线性插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "linear");
// 返回： array(2.25,4.8182)
3、"spline" 三次样条插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "spline");
// 返回： array(1.1407,13.9444)
4、"pchip" 分段三次hermite插值
x_ := array(5, 1, 19, 8);
y_ := array(2, 3, 1, 7);
xi := array(4, 12);
return interp(x_, y_, xi, "pchip");
// 返回： array(2.0156,6.7115)
```
## `intLinProg(f, a, b, aeq, beq, int_par)`
声明：function
（线性规划，包括整数规划，01规划建议统一使用prog_L函数）解决如下整数规划模型问题
| 参数 | 类型 | 说明 |
| --------- | ------------- | -------------------------------------------------------------------------------------------- |
| `f` | array of real | 一维实数数组，表示整数规划模型的目标函数系数； |
| `a` | array of real | 二维实数数组，表示整数规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b` | array of real | 一维实数数组，表示整数规划模型带“”约束方程的约束值； |
| `aeq` | array of real | 二维实数数组，表示整数规划模型带“=”约束方程系数矩阵； |
| `beq` | array of real | 一维实数数组，表示整数规划模型带“=”约束方程的约束值； |
| `int_par` | array of real | 一维整数数组，表示要取整数的变量，缺省时表示全部变量取整； |
返回：array
### 示例
```tsl
Find x that Maximum
f(x) =40x1+90x2
subject to
9x1+7x2≤ 56
7x1 + 20x2≤ 70
0 ≤ x1, 0 ≤ x2
x1, x2整数
// TSL代码：
f := array(-40, -90);
a := array((9, 7), (7, 20));
b := array(56, 70);
aeq := array();
beq := array();
int_par := array();
return intLinProg(f, a, b, aeq, beq, intpar);
// 结果：x1=4,x2=2,f(x)=-340
```
## `isDefinite(h)`
声明：function
判断矩阵是否正定、半正定，采用 Cholesky 分解方法
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `h` | array | array 样本 |
返回：real
### 示例
```tsl
x := array((3, 1), (1, 4));
return isDefinite(x); // 1
```
## `isSymmetry(a, tol)`
声明：function
判断是否为对称矩阵
| 参数 | 类型 | 说明 |
| ----- | ----- | -------------- |
| `a` | array | array 二维数组 |
| `tol` | real | real 精度 |
返回：integer
### 示例
```tsl
a := array((2, 1), (1, 3));
return isSymmetry(a, 0.1); // 1
```
## `kurt(t, real)`
声明：function
峰度。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------------------- |
| `t` | array | 一维数字数组，一维数据 |
| `real` | | 实数，返回的峰度 |
返回：any
### 示例
```tsl
kurt(array(1, 2, 3, 4, 5), s);
return s;
// 返回：-1.2
```
## `LeastSquares_CurveFitting(f, y)`
声明：function
最小二乘法进行回归
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------- |
| `f` | array | 二维数字数组类型，系数矩阵 |
| `y` | array | 一维数字数组类型，观察数据值 |
返回：array
## `linear(x, y, xi)`
声明：function
线性插值
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------- |
| `x` | array | 一维数组 横坐标序列 |
| `y` | array | 一维数组 纵坐标序列 |
| `xi` | array | 一维数组 插值点序列 |
返回：array
### 示例
```tsl
uses interp_unit; // 置顶
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xi := array(4, 12);
return interp_unit.linear(x, y, xi);
// 输出：array(2.66666666666667,1.77777777777778)
```
## `linearProgramming(f, a, b, aeq, beq)`
声明：function
（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,解决如下线性规划模型问题
| 参数 | 类型 | 说明 |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `f` | array of real | 一维实数数组，表示线性规划模型的目标函数系数； |
| `a` | array of real | 二维实数数组，表示线性规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b` | array of real | 一维实数数组，表示线性规划模型带“”约束方程的约束值； |
| `aeq` | array of real | 二维实数数组，表示线性规划模型带“=”约束方程系数矩阵； |
| `beq` | array of real | 一维实数数组，表示线性规划模型带“=”约束方程的约束值； |
返回：any
### 示例
```tsl
Find x that minimizes
f(x) = –5x1 – 4x2 –6x3,
subject to
x1 – x2 + x3 ≤ 20
3x1 + 2x2 + 4x3 ≤ 42
3x1 + 2x2 ≤ 30
0 ≤ x1, 0 ≤ x2, 0 ≤ x3.
// TSL代码：
f := array(-5, -4, -6);
a := array((1, -1, 1), (3, 2, 4), (3, 2, 0));
b := array(20, 42, 30);
aeq := array();
beq := array();
return linearProgramming(f, a, b, aeq, beq);
// 结果：x1=0,x2=15,x3=3,f(x)=-78
```
## `LnRegression_CallBack(x)`
声明：function
Ln(x)回归回调函数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 二维数字数组类型 |
返回：array
## `maxDrawDown(data, updn, interval, ifabs)`
声明：function
最大回撤
| 参数 | 类型 | 说明 |
| ---------- | ------- | ----------------------------------------------- |
| `data` | array | 一维数字序列 |
| `updn` | bool | 涨跌标示符。1为求最大涨，0为求最大跌（默认值） |
| `interval` | integer | 最大区间，为空或者小于1时，求整个区间（默认值） |
| `ifabs` | float | 预留字段，暂时没有实际意义，可不给值 。 |
返回：real/table
### 示例
范例01：
```tsl
// 计算一组序列的最大涨幅
data := array(3, 1, 7, 5, 6, 3);
return maxDrawDown(data, 1);
// 结果：
1
2
6
6
// 输出：说明：入点为data[1]，出点为data[2]，两者差为6，最大涨幅比例差为6
```
范例02：
```tsl
// ------计算100日股票的最大跌幅
setSysParam(pn_stock(), 'SZ000002');
setSysParam(pn_date(), 20181031T);
setSysParam(pn_rate(), 1);
setSysParam(pn_rateday(), 20181031T);
setSysParam(pn_cycle(), cy_day());
data := nDay3(100, close());
t := maxDrawDown(data);
return t;
// 结果t：
12
43
6.96759
0.25765
// 注：若需计算最大跌幅率，则只需t[3] * 100即可。
```
## `mbbub(p, z)`
声明：function
排序，对数组P按照从小到大的顺序排序，把数组排序的顺序对应的下标值返回到数组Z中
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `p` | array | 一维数字数组类型 |
| `z` | array | 一维数字数组类型 |
返回：array
### 示例
```tsl
p := array(2.72, 1.24, 1.31, 0.02, 0.88, 2.18);
return mbbub(p, z);
```
## `meanAndPopnStdDevWithRate(data, rate, mean, stddev)`
声明：function
带权重总体标准差以及平均值。
| 参数 | 类型 | 说明 |
| -------- | ----- | -------------------- |
| `data` | array | 一维数字数组 |
| `rate` | array | 一维数字数组 |
| `mean` | real | 实数，均值，返回值 |
| `stddev` | real | 实数，标准差，返回值 |
返回：real
### 示例
```tsl
meanAndPopnStdDevWithRate(array(1, 2, 3), array(1, 1, 1), m, s);
return m;
// 返回：2
```
## `mergeGraph(g1, g2, g3, gn)`
声明：function
将运行结果为图像的多个参数图像叠加，返回叠加后的图形组合。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------- |
| `g1` | graph | 图形1，一般是由graph函数返回的图形 |
| `g2` | graph | 图形2，一般是由graph函数返回的图形 |
| `g3` | graph | 图形3，一般是由graph函数返回的图形 |
| `gn` | graph | 图形n，一般是由graph函数返回的图形 |
返回：graph
### 示例
```tsl
setSysParam(pn_stock(), 'SZ000063');
setSysParam(pn_date(), 20190301T);
setSysParam(pn_nday(), 100);
t1 := nDay2(gfOpen(), open() ,
gfClose(), close(),
gfHigh(), high(),
gfLow(), low(),
gfTime(), dateTimeToStr(sp_time()),
// KLine颜色
gfColor(), ifThen3(close(), open(),
clRed() , // 涨颜色
clYellow() , // 平颜色
clLime() // 跌颜色
),
gfFill(), ifThen3(close(), open(), flClear(), flSolid(), flSolid())
);
t2 := nDay2('MA5', ma(close(), 5)); // 5日均线
t3 := nDay2('MA10', ma(close(), 10)); // 10日均线
t4 := nDay2('MA20', ma(close(), 20)); // 20日均线
g1 := graph(gtKLine(), 'KLine', t1);
g2 := graph(gtLine(), 'MA5', t2);
g3 := graph(gtLine(), 'MA10', t3);
g4 := graph(gtLine(), 'MA20', t4);
return mergeGraph(g1, g2, g3, g4);
// 返回:
```
## `minRecoveryTime(r, n1, n2)`
声明：function
最小恢复时间
| 参数 | 类型 | 说明 |
| ---- | ------- | -------------------- |
| `r` | array | (一维数字数组) 序列, |
| `n1` | integer | Int 买入点位置, |
| `n2` | integer | Int 卖出点位置 |
返回：integer
### 示例
```tsl
// 科大讯飞(SZ002230)在20201220最近十个交易日序列中第一天购买第二天卖出后的最小恢复时间
setSysParam(pn_stock(), "SZ002230");
setSysParam(PN_Date(), 20201220t);
r := nDay(10, "close", close())[: , "close"];
return minRecoveryTime(r, 0, 1);
// 输出：6
```
## `multipleExecute(exp)`
声明：function
表达式求值
| 参数 | 类型 | 说明 |
| ----- | ----------- | ------ |
| `exp` | texpression | 表达式 |
返回：array
## `multipleRegression(x, y, call_back)`
声明：function
多元回归
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------------ |
| `x` | array | 二维数字数组类型,观察数据点 |
| `y` | array | 一维数字数组类型,观察数据值 |
| `call_back` | string | 字符串类型，计算系数矩阵的回调 |
返回：array
### 示例
```tsl
x:=array((0.00,0.00),(0.00,1.00),(1.00,0.00),(1.00,1.00));
y:=array(1.00,2.00,2.00,3.00);
call_back:='MultipleRegression_CallBack';
multipleRegression(x,y,call_back);
//结果：
```
## `MultipleRegression_CallBack(x)`
声明：function
多元线性回归的回调函数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 二维数字数组类型 |
返回：array
## `MultipleRegression_Pgm(x, y)`
声明：function
多元线性回归测试
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 二维数字数组类型 |
| `y` | array | 一维数字数组类型 |
返回：array
## `MultipleUnLinearRegression_Pgm(x, y, call_back)`
声明：function
多元非线性回归测试
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------------------- |
| `x` | array | 二维数字数组类型，观察数据点 |
| `y` | array | 一维数字数组类型，观察数据值 |
| `call_back` | string | 字符串类型 |
返回：array
## `MultiUnLineralRegression_CallBack(x)`
声明：function
多元非线性回归的回调函数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 二维数字数组类型 |
返回：array
## `multyValue(v1, v2)`
声明：function
乘法（财务分析）
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |
返回：real
### 示例
```tsl
// 返回取-3与-5的乘积。
return multyValue(-3, -5);
// 结果：-15
```
## `mvtcdfqmc(a, b, rho, nu, options, funevals)`
声明：function
中间函数，采用蒙特卡洛计算多元t分布，估计概率P值以及误差
| 参数 | 类型 | 说明 |
| ---------- | ----- | -------------------------------------- |
| `a` | array | 可选。数组下限，默认为负无穷 |
| `b` | array | 必填。数组下限或实际需计算分布的样本值 |
| `rho` | array | 数组，相关系数矩阵 |
| `nu` | float | 实数，自由度 |
| `options` | array | 数组，规划条件设置 |
| `funevals` | array | 线性回归的结果条件 |
返回：array
### 示例
范例01：
```tsl
rho := array(
(1, 0.923912552224476, 0.035770327030089),
(0.923912552224476, 1, 0.084276570941762),
(0.035770327030089, 0.084276570941762, 1)
);
return mvtcdfqmc(array(0, 0, 0), array(0.2, 0.4, 0.6), rho, 2, array());
// 输出：近似 array(0.0077,0.0001)，每次运行可能略有差异。
```
## `nanMean(a)`
声明：function
计算含Nan一维数组的算术平均值
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
返回：real
### 示例
```tsl
a := array(5, 6, 8, nan);
return nanMean(a);
// 结果：6.33
```
## `nanPercentRankArr(a, f_name)`
声明：function
1、返回一维数组中的每个值在一维数组中的百分比排名
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------ |
| `a` | array | 数字数组，待计算的数组 |
| `f_name` | string | 字符串，字段名，默认为空 |
返回：array
### 示例
```tsl
a := array(1, 1, 2, 2, 2, 9, nan, 9, 9);
return nanPercentRankArr(a);
// 结果：array(0.0,0.0,0.29,0.29,0.29,0.71,NAN,0.71,0.71)
```
## `nanPopnStd(a)`
声明：function
计算含Nan一维数组的总体标准差
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
返回：real
### 示例
```tsl
a := array(5, 6, 8, nan);
return nanPopnStd(a);
// 结果：1.25
```
## `nanPopnVariance(a)`
声明：function
计算含Nan一维数组的总体方差
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
返回：real
### 示例
```tsl
a := array(5, 6, 8, nan);
return popnVariance(a);
// 结果：1.56
```
## `nanRankArr(a, f_name, sortorder)`
声明：function
1、返回一维数组中的每个值在一维数组中的排位
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------ |
| `a` | array | 数字数组，待计算的数组 |
| `f_name` | string | 字符串，字段名，默认为空 |
| `sortorder` | bool | 排序方向，默认为1 |
返回：array
### 示例
```tsl
a := array(1, 1, 2, 2, 2, 9, nan, 9, 9);
return nanRankArr(a);
// 结果：array(1,1,3,3,3,6,NAN,6,6)
```
## `nanStd(a)`
声明：function
计算含Nan一维数组的标准差的估计（样本标准差）
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
返回：real
### 示例
```tsl
a := array(5, 6, 8, nan);
return nanStd(a);
// 结果：1.53
```
## `nanSum(a)`
声明：function
计算含Nan一维数组的总和
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
返回：real
### 示例
```tsl
a := array(5, 6, 8, nan);
return nanSum(a);
// 结果：19
```
## `nanVariance(a)`
声明：function
计算含Nan一维数组的方差的估计（样本方差）
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `a` | array | 一维数字数组 |
返回：real
### 示例
```tsl
a := array(5, 6, 8, nan);
return nanVariance(a);
// 结果：2.33
```
## `nchoosek(n, k)`
声明：function
样本组合
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------ |
| `n` | array | 样本(一维数组) |
| `k` | integer | 每组样本数量(整数) |
返回：array
### 示例
```tsl
Returnnchoosek(array('a', 'b', 'c', 'd'), 2);
// 输出：
array(
("d", "c"),
("d", "b"),
("d", "a"),
("c", "b"),
("c", "a"),
("b", "a"))
```
## `NonLP_BSearch(fun, x0, h)`
声明：function
一维盲人搜索方法，目标函数既可以是单峰，也可以是多峰。返回最优点和最优值。（中间函数）
| 参数 | 类型 | 说明 |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0` | float | 初值，为实数类型； |
| `h` | float | 步长，为实数类型； |
返回：array
## `NonLP_Fibonacci(fun, a, b)`
声明：function
（一维最小值搜索建议统一使用NonLP_Fminbnd函数），斐波那契法，用斐波那契数列去搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a` | float | 区间左侧，为实数类型； |
| `b` | float | 区间右侧，为实数类型 |
返回：array
## `NonLP_Fminbnd(fun, a, b, methods)`
声明：function
一维最小值搜索，求解模型如下： min fun(x)
| 参数 | 类型 | 说明 |
| --------- | ------ | ------------------------------------------------------------------------------ |
| `fun` | string | 目标函数(函数名字符串) |
| `a` | float | 下界，实数 |
| `b` | float | 上界，实数 |
| `methods` | any | 方法选择0 :黄金分割法+抛物线法（默认）1 : 盲人收索法2 :黄金分割法3 :斐波那契法 |
返回：array
## `NonLP_Fmincon(fun, x0, a, b, aeq, beq, nonlcon, c, methods)`
声明：function
（非线性规划建议统一使用prog_n函数）默认选项只适合于单纯的等式约束问题或者单纯的不等式约束问题，罚函数+转轴法/模式搜索法适合于任何问题，结果返回最优点、最优值和迭代次数。 可求解如下问题：
| 参数 | 类型 | 说明 |
| --------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型； |
| `a` | array | 线性矩阵不等式约束，为二维数组类型； |
| `b` | array | 线性向量不等式约束值，为一维数组类型； |
| `aeq` | array | 线性矩阵等式约束，为二维数组类型； |
| `beq` | array | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；nonlcon回调需用户自己新建一个函数，然后把函数名传进nonlcon，函数格式如下:；Function “函数名”(x);；Begin |
| `c` | any | =array();//\*；C\[0\]:=……；C\[1\]:=……；……；Ceq:=array();//\*；Ceq\[0\]:=……；Ceq\[1\]:=……；……；Return array(0:c,1:ceq);//\*；End;；//\*号的式子一定要写 |
| `methods` | any | 优化方法（0:默认，1:罚函数+转轴法，2:罚函数+模式搜索法），为用户自定义类型（整型）； |
返回：array
## `NonLP_Fminsearch(fun, x0, methods)`
声明：function
无约束最小值求解,求解模型如下： min fun(x)
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------------------------------------------------------- |
| `fun` | string | 目标函数，函数名字符串 |
| `x0` | array | 初始值，一维数字数组 |
| `methods` | any | 方法选择0 单纯形法1 转轴法2 模式搜索法3 拟牛顿下山法（默认方法，推荐使用） |
返回：array
## `NonLP_Golden(fun, a, b)`
声明：function
（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割法搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a` | float | 区间左侧，为实数类型； |
| `b` | float | 区间右侧，为实数类型 |
返回：array
## `NonLP_GP(fun, a, b)`
声明：function
（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割+抛物线插值法：一维优化方法，返回最优点和最优值
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a` | float | 区间左侧，为实数类型； |
| `b` | float | 区间右侧，为实数类型； |
返回：array
## `NonLP_Hooke_Jeeves(fun, x0)`
声明：function
（无约束最小值求解建议统一使用NonLP_Fminsearch函数）模式搜索法，又叫Hooke-Jeeves法，求解无约束多维极值问题，返回最优点和最优值。
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型 |
返回：array
## `NonLP_minFactor(fun, x0, aeq, beq, nonlcon)`
声明：function
（非线性规划建议统一使用prog_n函数）,乘子法求等式约束问题，可求解如下问题：
| 参数 | 类型 | 说明 |
| --------- | ------ | ------------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型； |
| `aeq` | array | 线性矩阵等式约束，为二维数组类型； |
| `beq` | array | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型； |
返回：array
## `NonLP_minPS(fun, x0, a, b, nonlcon)`
声明：function
（非线性规划建议统一使用prog_n函数）,坐标轮换法求不等式约束问题，初值必须在可行域内！可求解如下问题：
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型； |
| `a` | array | 线性矩阵不等式约束，为二维数组类型； |
| `b` | array | 线性向量不等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型； |
返回：array
## `NonLP_minSUMT(fun, x0, a, b, aeq, beq, nonlcon, methods)`
声明：function
（非线性规划建议统一使用prog_n函数）混合惩罚函数+转轴法/模式搜索法：可解所有优化问题，返回最优点、最优值和迭代次数。可求解如下问题：
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型； |
| `a` | array | 线性矩阵不等式约束，为二维数组类型； |
| `b` | array | 线性向量不等式约束值，为一维数组类型； |
| `aeq` | array | 线性矩阵等式约束，为二维数组类型； |
| `beq` | array | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型； |
| `methods` | string | 方法选择,’NM’,’Rb’,’HJ’ |
返回：array
## `NonLP_Nelder(fun, x0)`
声明：function
（无约束最小值求解建议统一使用NonLP_Fminsearch函数）内德-米德法，无约束多维的非线性规划方法，即单纯形法。返回最优点和最优值。
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型 |
返回：array
## `NonLP_Range(fun, x0, h)`
声明：function
进退法，可一维优化问题的确定搜索区间，但目标函数必须是单峰函数，返回结果为上下界的取值。（中间函数）
| 参数 | 类型 | 说明 |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0` | float | 初值，为实数类型； |
| `h` | float | 步长，为实数类型； |
返回：array
## `NonLP_Rosenbrock(fun, x0)`
声明：function
（无约束最小值求解建议统一使用NonLP_Fminsearch函数）Rosenbrock求无约束多维极值问题，返回最优点和最优值。
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0` | array | 初值向量，为一维数组类型 |
返回：array
## `norm2(a, flag)`
声明：function
范数
| 参数 | 类型 | 说明 |
| ------ | ------ | ----------------- |
| `a` | array | 二维数字数组 样本 |
| `flag` | string | string 范数类型 |
返回：real
### 示例
```tsl
a := array((2, 1), (1, 3));
return norm2(a, 'inf'); // 4
```
## `Norm_LinearTransform(mu, sigma, a, b)`
声明：function
正态分布线性变换，得到变换后的均值、协方差或方差
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------- |
| `mu` | array | 实数或二维数组（n\*1），原正态分布均值 |
| `sigma` | array | 实数或二维数组（n\*1），原正态分布方差 |
| `a` | array | 实数或二维数组（n\*1），线性变换常数项 |
| `b` | array | 实数或二维数组（n\*1），线性变换系数项 |
返回：array
## `normfit(x, alpha)`
声明：function
根据样本x，x服从正态分布，估计该正态分布的两个参数ma,sigma
| 参数 | 类型 | 说明 |
| ------- | ------------- | -------------------------- |
| `x` | array of real | 正态分布样本，一维数字数组 |
| `alpha` | real | 显著性水平，在0-1之间 |
返回：any
### 示例
```tsl
x := randnorm(0, 1, 10, array("a", "b"));
return normfit(x, 0.05);
// 输出：返回mu, sigma的估计以及他们的在alpha的显著性水平下的区间估计
```
## `norminv(p, mu, sigma)`
声明：function
正态逆函数
| 参数 | 类型 | 说明 |
| ------- | -------------- | ---------------- |
| `p` | float \| array | 正态分布的概率 |
| `mu` | float | 分布的算术平均值 |
| `sigma` | float | 方差 |
返回：float | array
### 示例
```tsl
return norminv(0.15, 0.5, 1); // -0.5364
```
## `normPlot(x, return_type)`
声明：function
基于正态概率的正态性检验, ReturnType为0时返回我们常说的QQ图的散点数据，为1返回衡量散点与直线拟合程度的可决系数
| 参数 | 类型 | 说明 |
| ------------- | ------------- | ----------------------------------------------------------------- |
| `x` | array of real | 检验样本序列，为一维数组类型 |
| `return_type` | integer | 返回类型选项，为0返回散点数据，为1返回直线拟合的可决系数。缺省为0 |
返回：array
### 示例
```tsl
x := rand(10);
return normPlot(x);
// 输出：
array(
("采样位数": 0.171976955840364, "理想位数": -1.64484977722168),
("采样位数": 0.301570532377809, "理想位数": -1.03643536567688),
("采样位数": 0.470976530341431, "理想位数": -0.674489885568619),
("采样位数": 0.479131903499365, "理想位数": -0.38532167673111),
("采样位数": 0.678062069928274, "理想位数": -0.125661492347717),
("采样位数": 0.735156666953117, "理想位数": 0.125661492347717),
("采样位数": 0.739045920781791, "理想位数": 0.38532167673111),
("采样位数": 0.780685598030686, "理想位数": 0.674489885568619),
("采样位数": 0.817699506180361, "理想位数": 1.03643536567688),
("采样位数": 0.828364443266764, "理想位数": 1.64484977722168))
QQ图形：
return normPlot(x, 1);
// 输出：0.911334081735257
```
## `NW_Adjustment_Simplification(y, alpha, al)`
声明：function
在单因子有效性的检验中，进行检验的往往是组合收益率序列或者因子收益率序列在 时序上是否显著异于零，这一过程本身并不涉及回归过程，因此无法直接使用上一节中介绍的调整方法。然而，我们知道组合收益或者因子收益在时序上极有可能存在异方差和自相关特性，因此在计算序列标准误时，必须对其进行 Newey-West 调整，从而得到其标准差的一致性估计，进而得到更稳健的 t 值。 关于这个问题Bali et al(2016)指出对于单个因子收益率序列的显著性检验，我们可以将其转换为一个简单的线性回归模型：将 1 作为自变量，将因子收益率作为因变量，进行回归得到残差变量。此时残差项即为因子收益率减去它在时间序列上的均值。把残差项和X=1代入即可得到简化的结果，对Q的估计形式如下：QNW-Simple=1Tt=1Tet2+l=1Lt=l+1Twletet-l 其中，wl=1-l1+L 这里的Q实际上不是矩阵，只是一个数。 将Q代入Cov\[β\*\]中就可以求出收益率方差的估计，之后就可以进行T检验了。σ2=QNW-Simple/T
| 参数 | 类型 | 说明 |
| ------- | ----- | ------------------------------------------------------------------------------------- |
| `y` | array | 一维数字数组, 因变量 |
| `alpha` | float | 实数，显著性水平，应为0到1之间的值，默认0.05 |
| `al` | any | 整数，自相关最大滞后阶数，可缺省，默认用Newey and West (1994)?提出的方法计算，至少为1 |
返回：array
## `orth(a)`
声明：function
矩阵范围内的标准正交基向量
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `a` | array | 数组， |
返回：array
### 示例
```tsl
// 计算矩阵A的标准正交基
a := array((0, 1), (1, 1), (1, 0));
return orth(a);
```
## `outPutGrowRatio(v1, v2)`
声明：function
增长率(%)
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `v1` | float | 实型，期末值 |
| `v2` | float | 实型，期初值 |
返回：float
### 示例
```tsl
//返回13到14的增长率(%)
outPutGrowRatio(14,13);
//结果：7.69
```
## `outPutGrowRatio2(v1, v2)`
声明：function
增长率(%)
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `v1` | float | 实型，期末值 |
| `v2` | float | 实型，期初值 |
返回：float
### 示例
```tsl
//返回13到14的增长率(%)
outPutGrowRatio2(14,13);
//结果：7.69
```
## `outPutGrowRatio3(v1, v2)`
声明：function
增长率(%)
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |
返回：real
### 示例
```tsl
// 返回14到13的增长率(%)
return outPutGrowRatio3(14, 13);
// 结果：7.69
```
## `outPutGrowValue(v1, v2)`
声明：function
增长
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |
返回：real
### 示例
```tsl
// 返回13与14的差值
return outPutGrowValue(13, 14);
// 结果：-1
```
## `outPutGrowValue2(v1, v2)`
声明：function
增长
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `v1` | float | 实型，期末值 |
| `v2` | float | 实型，期初值 |
返回：float
### 示例
```tsl
//返回13与14差值
outPutGrowValue2(13,14);
//结果：-1
```
## `outPutGrowValue3(v1, v2)`
声明：function
增长
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |
返回：real
### 示例
```tsl
// 返回13与14的差值
return outPutGrowValue3(13, 14);
// 结果：-1
```
## `outPutLnGrowRatio(v1, v2)`
声明：function
对数增长率输出(%)。
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |
返回：real
### 示例
```tsl
// 取3与4的对数增长率
return outPutLnGrowRatio(3, 4);
// 结果：-28.77
```
## `outPutValueByUnit(data_type, data_unit)`
声明：function
单位转换。
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------- |
| `data_type` | string | 字符串，数据类型 |
| `data_unit` | real | 实型，指定单位 |
返回：real
### 示例
```tsl
// 返回1234.5以10为单位转换后的结果
return outPutValueByUnit(1234.5, 'Real', 10);
// 结果：123.45
```
## `ozProg(f, a, b)`
声明：function
（线性规划，包括整数规划，01规划建议统一使用prog_L函数）,0-1规划，解决如下0-1整数规划模型问题 返回该0-1规划模型的最小值及其对应变量的取值,其中可以转化为和；
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------------------------------------------------------------------- |
| `f` | array | 一维实数数组，表示0-1规划模型的目标函数系数； |
| `a` | array | 二维实数数组，表示0-1规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b` | array | 一维实数数组，表示0-1规划模型带“”约束方程的约束值； |
返回：array
### 示例
```tsl
f:=array(-3,2,-5);
a:=array((1,2,-1),(1,4,1),(1,1,0),(4,0,1));
b:=array(2,4,3,6);
ozProg(f,a,b);
//结果：x1=1,x2=0,x3=1,f(x)=-8
```
## `percentage(y, per, style)`
声明：function
百分位去极值
| 参数 | 类型 | 说明 |
| ------- | ----------- | ------------------------------------------------------------------------------------------- |
| `y` | array | 数字数组，待处理数据 |
| `per` | real\|array | 实数或者一维数字数组，去极值百分位；5表示 5%； |
| `style` | integer | 整数，0 或者不输入时 去 百分位大于 per 和小于per的；1, 去除小于per的；2 去除 大于per的 数据 |
返回：array
### 示例
```tsl
y := rand(100, 2);
per := 20;
style := 0;
return percentage(y, per, style);
```
## `percentileOfScore(data, score, _type)`
声明：function
百分位占比(%)
| 参数 | 类型 | 说明 |
| ------- | ------- | ---------------- |
| `data` | array | 数组 待处理数据, |
| `score` | float | float 待排序值, |
| `_type` | integer | 算法 |
返回：array
### 示例
```tsl
// 去除随机数组的极值
data := array(1, 2, 2, 4);
ret := array();
n := 0;
for i := 0 to 5 do
begin
ret[n, 'score'] := i;
for j, kind in array('rank', 'strict', 'weak', 'mean')do
begin
ret[n, kind] := percentileOfScore(data, i, j);
end
ret[n, 'percenrank'] := percentrank(data, i);
n++;
end;
return ret;
```
## `perms(x)`
声明：function
样本排列
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 样本，数组或数字 |
返回：array
### 示例
范例01：求10的阶乘
```tsl
return perms(10);
// 输出：3628800
```
范例02：排列组合
```tsl
return perms(array("a", "b", "c"));
// 输出：
array(
("c", "b", "a"),
("c", "a", "b"),
("b", "c", "a"),
("b", "a", "c"),
("a", "b", "c"),
("a", "c", "b"))
```
范例03：返回数组Array(('A','B'),('C', 'D'))中任意两个数据的排列组合
```tsl
v := Array(('A', 'B'), ('C', 'D'));
return perms(v, 2);
```
范例04：对排列组合的每列求和
```tsl
function test_1cth();
begin
func := createobject("funcexe");
a := array("A", "B", "C");
return perms(a, 3, func);
end;
type funcexe = class()
data;
function create();
begin
data := "";
end
function exe(dat);
begin
data+=dat;
end
end
```
## `PieLine_Web(r, graph_title, return_type)`
声明：function
返回饼图。
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------ |
| `r` | array | 数据表类型，数据； |
| `graph_title` | string | 字符串，图形标题； |
| `return_type` | any | 整数，返回类型。 |
返回：array
## `pinv(a, t)`
声明：function
伪逆
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------- |
| `a` | array | array 矩阵 |
| `t` | real | real 精度 默认为 2.220446049250313e-016 |
返回：array
### 示例
```tsl
x := array((9, 1), (-1, 0), (0, 2), (1, 1));
return pinv(x);
```
## `poissfit(x, alpha)`
声明：function
根据样本x，x服从泊松分布，估计该分布的参数lambda
| 参数 | 类型 | 说明 |
| ------- | ------------- | ---------------------- |
| `x` | array of real | 泊松分布样本，数字数组 |
| `alpha` | real | 显著性水平，在0-1之间 |
返回：any
### 示例
```tsl
x := randpoiss(1, 100);
return poissfit(x, 0.05);
// 输出：返回lambda的估计以及他们的在alpha的显著性水平下的区间估计
```
## `polynomialRegression(x, y, m)`
声明：function
多项式回归
| 参数 | 类型 | 说明 |
| ---- | ------- | --------------------------- |
| `x` | array | 一维数字数组类型,观察数据点 |
| `y` | array | 一维数字数组类型,观察数据值 |
| `m` | integer | 整数类型，拟合最大阶数 |
返回：array
### 示例
```tsl
x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
return polynomialRegression(x, y, 1);
```
## `PolynomialRegression_Pgm(x, y, m)`
声明：function
多项式回归测试
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------- |
| `x` | array | 一维数字数组类型 |
| `y` | array | 一维数字数组类型 |
| `m` | any | 整数类型，拟合最大阶数 |
返回：array
## `princaipalComponentAnalysis(zt)`
声明：function
主成分分析
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `zt` | array | 二维数字数组类型，样本矩阵 |
返回：array
### 示例
```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
return princaipalComponentAnalysis(zt);
```
## `princomp(x, ep, is_stand, resid)`
声明：function
主成分分析，isStand为0时从中心化协方差出发进行主成分分析，为1时从相关系数出发，进行主成分分析；
| 参数 | 类型 | 说明 |
| ---------- | ------------- | ------------------------------------------- |
| `x` | array of real | 样本数据，二维数字数组; |
| `ep` | real | 累计方差贡献度阈值，实数，缺省时默认为0.85; |
| `is_stand` | bool | 是否标准化，布尔类型，缺省时为真； |
| `resid` | array | 残差，变参输出，二维数字数组； |
返回：array
### 示例
```tsl
data := array(
(947.00, 23.4, 14.8, 45.3, 0.46, 85.2, 373.00, 9.54, 0.37, 3.88),
(935.00, 23.2, 16.2, 41.7, 0.4, 83.3, 305.00, 7.9, 0.38, 4.81),
(918.2, 20.9, 14.8, 43.8, 0.38, 82.6, 320.00, 9.51, 0.43, 4.52),
(910.7, 23.4, 16.1, 44.00, 0.46, 85.2, 338.00, 8.6, 0.33, 3.84),
(905.00, 22.9, 17.00, 39.8, 0.45, 80.4, 348.00, 9.53, 0.42, 4.4),
(890.6, 22.3, 15.7, 44.00, 0.41, 85.4, 286.00, 8.67, 0.39, 4.5),
(853.4, 20.9, 15.9, 41.6, 0.35, 85.4, 273.00, 9.79, 0.42, 4.29),
(837.3, 20.2, 14.4, 37.3, 0.33, 82.5, 326.00, 7.62, 0.36, 4.73),
(833.3, 22.2, 15.2, 38.3, 0.37, 82.2, 310.00, 7.84, 0.4, 5.1),
(760.9, 20.4, 15.5, 40.7, 0.32, 84.2, 268.00, 7.75, 0.35, 4.52),
(760.3, 20.8, 15.1, 44.8, 0.35, 79.5, 273.00, 8.91, 0.45, 5.05),
(742.5, 23.4, 14.7, 43.1, 0.35, 79.5, 310.00, 9.13, 0.4, 4.36));
return princomp(data, 0.85, 1, resid);
```
## `Prog_L(f, a, b, aeq, beq, lb, ub, x0, options, ozarr, intarr)`
声明：function
使用单纯形法，和起作用集法，系统默认作用集形法求解线性规划问题，即求解目标都为线性和约束条件都为线性的规划问题 Prog_L(f,A,b) 求解不等式约束 Prog_L(f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_L(f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options) 求解不等式约束、等式约束，上下限约束，加入用户算法设置 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr) 求解不等式约束、等式约束、上下限约束、0-1 约束 Prog_L(f,A,b,Aeq,beq,LB,UB,x0,options,ozarr,intarr) 求解不等式约束、等式约束、上下限约束、0-1 约束、整数约束 模型表达： min= sum(f\*x) st. A:\*x<=b Aeq :\* x = Beq lb<x<ub x = (0 or 1) x = integer
| 参数 | 类型 | 说明 |
| --------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `f` | array | 线性目标，一维数字数组，不可缺省 |
| `a` | array | 线性约束，二维数字数组，不可缺省 |
| `b` | array | 线性约束，一维数字数组，不可缺省 |
| `aeq` | array | 线性约束，二维数字数组，缺省为空 |
| `beq` | array | 线性约束，一维数字数组，缺省为空 |
| `lb` | array | 下界约束，一维数字数组，缺省为空 |
| `ub` | array | 上界约束，一维数字数组，缺省为空 |
| `x0` | array | 初始值，一维数组 |
| `options` | array | 选项设置，数据表类型，缺省为:；array( 'algorithm' :'activeset'，//'simplex' 单纯形，'activeset' 作用集法；//(当整数、0-1 约束时推荐使用)；'maxiter': 400 , //最大迭代次数；'tolcon': 1.0e-10, //约束容忍误差；'tolfun' : 1.0e-8 , //目标最小误差；'tolx' : 1.0e-8 //变量最小变化) |
| `ozarr` | array | 01约束条件，第1个变量为01变量则ozarr := array(0) |
| `intarr` | array | 整数约束条件，第2,3两个变量为整数变量则 intarr:=array(1,2)；返回结果:；数据表类型；ret\["X"\] : 变量取值，一维数字数组；ret\["Fval"\] :规划目标值，实数；ret\["Error_M"\] : 结果信息，整数；ret\["Iter"\] : 迭代次数,整数 |
返回：array
## `Prog_M(fun, x0, goal, weight, a, b, aeq, beq, lb, ub, nlc, options)`
声明：function
求解多目标规划问题 模型表达： min AttainFactor st. f(x)-AttainFactor\*wight <=goal //目标约束 c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A\*x<=b; //线性不等式约束 aeq\*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束
| 参数 | 类型 | 说明 |
| --------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun` | array | 目标函数，函数名字符串 |
| `x0` | array | 初始值 |
| `goal` | array | 目标中各个分目标的差，一维数组和目标个数相同 |
| `weight` | array | 目标中各个分量的在总体中的比重，一维数组和目标个数相同 |
| `a` | array | 不等式约束，二维数组 |
| `b` | array | 不等式约束，一维数组 |
| `aeq` | array | 等式约束，二维数组 |
| `beq` | array | 等式约束，一维数组 |
| `lb` | array | 下界，一维数组 |
| `ub` | array | 上界，一维数组 |
| `nlc` | string | 非线性约束，约束函数名字符串 |
| `options` | array | 算法参数设置，默认为:array('maxiter':400, //最大迭代次数'maxfunevals':'100\*numberofvariables', //目标回调最大次数'tolcon':1.0e-6,//约束容忍误差'tolfun' :1.0e-6,//目标最小误差'tolx' :1.0e-6, //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8)// 差分时最小步长 |
返回：array
## `Prog_N(fun, x0, a, b, aeq, beq, lb, ub, nlc, options)`
声明：function
采用拟牛顿下山方法求解非线性规划求解。 Prog_n(fun,x0) 无约束最小值约束 Prog_n(fun,x0,A,B) 非线性不等式约束求解 Prog_n(fun,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_n(fun,x0,A,b,Aeq,beq,LB,UB,x0,options) 模型表达 1非线性无约束最小值 min fun(x) 2非线性规划求解 min fun(x) st. c(x)<=0; //非线性不等式约束 ceq(x)=0; //非线性等式约束 A\*x<=b; //线性不等式约束 aeq\*x=beq; //线性等式约束 lb<=x<=ub ; //边界约束
| 参数 | 类型 | 说明 |
| --------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `fun` | array | 目标函数，目标函数名字符串类型，不可缺省。其中，目标函数的返回值必须是一个实数（1x1的矩阵，或长度为1的数组都不允许） |
| `x0` | array | 初始值，一维数字数组，不可缺省 |
| `a` | array | 不等式约束，二维数组，缺省为空 |
| `b` | array | 不等式约束，一维数组，缺省为空 |
| `aeq` | array | 等式约束，二维数组，缺省为空 |
| `beq` | array | 等式约束，一维数组，缺省为空 |
| `lb` | array | 下界，一维数组，缺省为空 |
| `ub` | array | 上界，一维数组，缺省为空 |
| `nlc` | array | 非线性约束，函数名，字符串 |
| `options` | array | 算法参数设置，默认为array('maxiter':400 , //最大迭代次数'maxfunevals':'100\*numberofvariables', //目标回调最大次数'tolcon':1.0e-6 ,//约束容忍误差'tolfun' :1.0e-6 ,//目标最小误差'tolx' :1.0e-6 , //变量最小变化'diffmaxchange':1e-1,//差分时最大步长'diffminchange':1e-8 )// 差分时最小步长 |
返回：array
## `Prog_Q(h, f, a, b, aeq, beq, lb, ub, x0, options)`
声明：function
二次规划问题求解(采用作用集方法) Prog_Q(H,f,A,b) 求解不等式约束 Prog_Q(H,f,A,b,Aeq,beq) 求解不等式约束、等式约束 Prog_Q(H,f,A,b,Aeq,beq,LB,UB) 求解不等式约束、等式约束、上下界限约束 Prog_Q(H,f,A,b,Aeq,beq,LB,UB,x0,options) 模型表达： min= `x\* H\* x /2 + sum(f\*x) st. A:\*x<=b Aeq :\* x = Beq; lb<x<ub;
| 参数 | 类型 | 说明 |
| --------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `h` | array | 二次型，正定二次型二维数字数组，不可缺省 |
| `f` | array | 线性目标，一维数字数组，不可缺省 |
| `a` | array | 线性约束，二维数字数组，不可缺省 |
| `b` | array | 线性约束，一维数字数组，不可缺省 |
| `aeq` | array | 线性约束，二维数字数组，缺省为空 |
| `beq` | array | 线性约束，一维数字数组，缺省为空 |
| `lb` | array | 下界约束，一维数字数组，缺省为空 |
| `ub` | array | 上界约束，一维数字数组，缺省为空 |
| `x0` | array | 初始值，一维数组 |
| `options` | array | 选项设置,数据表类型，缺省为array('maxiter': 400 , //最大迭代次数'tolcon': 1.0e-6, //约束容忍误差'tolfun' : 1.0e-6 , //目标最小误差'tolx' : 1.0e-6 //变量最小变化) |
返回：array
## `quadLagR(h, f, aeq, beq)`
声明：function
(二次规划建议统一使用prog_Q函数)解决如下二次规划模型问题:
| 参数 | 类型 | 说明 |
| ----- | ---------------- | ----------------------------------------------------- |
| `h` | array,tablearray | 二维实数数组，表示二次项目标函数系数，为对称矩阵 |
| `f` | array,tablearray | 一维实数数组，表示二次规划模型的目标函数系数； |
| `aeq` | array,tablearray | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵； |
| `beq` | array,tablearray | 一维实数数组，表示二次规划模型带“=”约束方程的约束值。 |
返回：any
### 示例
```tsl
Find x that minimize
f(x) = 2 * x1^2+x2^2+x1 * x2-x1-x2
subject to
x1 + x2 = 1
// TSL代码：
h := Array((4, 1), (1, 2));
f := Array(-1, -1);
aeq := array((1, 1));
beq := array(1);
return quadLagR(h, f, aeq, beq);
// 输出：解析：x1=0.25, x2=0.75, 最小值f(x)=-0.125
```
## `quadprog(h, f, a, b, aeq, beq)`
声明：function
（二次规划建议统一使用prog_Q函数）,解决如下二次规划模型问题：
| 参数 | 类型 | 说明 |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `h` | array of real | 二维实数数组，表示二次项目标函数系数，为对称矩阵 |
| `f` | array of real | 一维实数数组，表示二次规划模型的目标函数系数； |
| `a` | array of real | 二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b` | array of real | 一维实数数组，表示二次规划模型带“”约束方程的约束值； |
| `aeq` | array of real | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵； |
| `beq` | array of real | 一维实数数组，表示二次规划模型带“=”约束方程的约束值； |
返回：array
### 示例
```tsl
Find x that minimize
f(x) = 1/2 * x1^2+x2^2-x1 * x2-2x1-6x2
subject to
x1 + x2 ≤ 2
–x1 + 2x2 ≤ 2
2x1 + x2 ≤ 3
0 ≤ x1, 0 ≤ x2.
// TSL代码：
h := Array((1, -1), (-1, 2));
f := Array(-2, -6);
a := Array((1, 1), (-1, 2), (2, 1));
b := array(2, 2, 3);
aeq := array();
beq := array();
return quadprog(h, f, a, b, aeq, beq);
// 结果： x1=0.6667,x2=1.3333,f(x)=-8.2222
```
## `quadTrackRoute(h, f, a, b, aeq, beq, x0)`
声明：function
（二次规划建议统一使用prog_Q函数）解决如下二次规划模型问题:
| 参数 | 类型 | 说明 |
| ----- | ------------- | -------------------------------------------------------------------------------------------- |
| `h` | array of real | 二维实数数组，表示二次项目标函数系数，为对称矩阵 |
| `f` | | 一维实数数组，表示二次规划模型的目标函数系数； |
| `a` | array of real | 二维实数数组，表示二次规划模型的带“”约束方程系数矩阵，如果是带“”，则将该方程两边同乘以“-1”； |
| `b` | array of real | 一维实数数组，表示二次规划模型带“”约束方程的约束值； |
| `aeq` | array of real | 二维实数数组，表示二次规划模型带“=”约束方程系数矩阵； |
| `beq` | array of real | 一维实数数组，表示二次规划模型带“=”约束方程的约束值； |
| `x0` | array of real | 变量的初始点。 |
返回：array
### 示例
```tsl
Find x that minimize
f(x) = 2 * x1^2+2 * x2^2-x1 * x2+8 * x1-6x2
subject to
x1 + x2 ≤ 2
2 * x1 - x2 ≤ 1
// TSL代码：
h := Array((4, -1), (-1, 4));
f := Array(8, -6);
a := Array((1, 1), (2, -1));
b := array(2, 1);
aeq := array();
beq := array();
x0 := array(0, 0);
return quadTrackRoute(h, f, a, b, aeq, beq, x0);
// 输出：分析：x1=-1.733333, x2=1.066667, 最小值f(x)=-10.13333
```
## `randbeta(a, b, row, col)`
声明：function
产生贝塔分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ------------------------ |
| `a` | real | beta分布参数1,实数,大于0 |
| `b` | real | beta分布参数2,实数,大于0 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randbeta(2, 4, 100, array("a", "b"));
```
## `randbino(n, p, row, col)`
声明：function
产生二项分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------------------- |
| `n` | integer | 试验总量,为大于0的整数； |
| `p` | real | 一次试验成功的概率,为0,1之间的实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randbino(10, 0.5, 10, array("a", "b"));
```
## `randCauchy(a, b, row, col)`
声明：function
产生柯西的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `a` | real | 位置参数,实数 |
| `b` | real | 尺度参数,大于0的实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randCauchy(0, 2, 10, array("a", "b"));
```
## `randch2(cv, row, col)`
声明：function
产生卡方分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `cv` | real | 卡方分布自由度,实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randch2(30, 10, array("a", "b"));
```
## `randCopula(copula_type, rho, v, n)`
声明：function
生成服从copula分布的随机数
| 参数 | 类型 | 说明 |
| ------------- | ------- | --------------------------------------------------------------------------------- |
| `copula_type` | string | 字符串，分布函数类型:gaussian、t、clayton、frank、gumbel |
| `rho` | array | 数组，协方差矩阵，对阿基米德族(clayton、frank、gumbel分布)为空 |
| `v` | float | 实数，对t分布为自由度；对阿基米德族(clayton、frank、gumbel分布)为参数估计值，且其 |
| `n` | integer | 整数，产生随机数长度 |
返回：array
### 示例
范例01：gaussian分布
```tsl
rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
n := 10;
v := array((0, 0, 0), (0, 0, 0), (0, 0, 0));
return randCopula("gaussian", rho, v, n);
// 输出：10×3 数组；随机样本每次运行不同。
```
范例02：t分布
```tsl
rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
n := 10;
return randCopula("t", rho, 3, n);
// 输出：10×3 数组；随机样本每次运行不同。
```
范例03：阿基米德族，clayton(frank、gumbel调用相同)
```tsl
alpha := 1;
n := 10;
return randCopula("clayton", nil, alpha, n);
// 输出：10×2 数组；随机样本每次运行不同。
```
## `randexp(mu, row, col)`
声明：function
产生指数分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `mu` | real | 分布参数,实数,缺省为1 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randexp(1, 10, array("a", "b"));
```
## `randf(v1, v2, row, col)`
声明：function
产生F分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `v1` | real | 分子自由度,大于0的实数 |
| `v2` | real | 分母自由度,大于0的实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randf(20, 30, 10, array("a", "b"));
```
## `randgam(a, b, row, col)`
声明：function
产生伽马分布的随机数
| 参数 | 类型 | 说明 |
| ----- | ----- | ---------------------- |
| `a` | float | 形状参数,大于0的实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `row` | array | 行数或者行名字符串数组 |
| `col` | array | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
randgam(2,2,100,array("a","b"));
```
## `randgeo(n, p, row, col)`
声明：function
产生几何分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | -------------------------------------- |
| `n` | | 分布参数,整数； |
| `p` | real | p:一次试验成功的概率,为0,1之间的实数； |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randgeo(10, 10, array("a", "b"));
```
## `randhyge(m, k, n, row, col)`
声明：function
产生超几何分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `m` | integer | 总体数目,非负整数 |
| `k` | integer | 总体标数目,非负整数 |
| `n` | integer | 抽样数目,非负整数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randhyge(100, 10, 20, 10, array("a", "b"));
```
## `randLaplace(mu, b, row, col)`
声明：function
产生拉普拉斯的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `mu` | real | 位置参数,实数 |
| `b` | real | 尺度参数,大于0的实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randLaplace(0, 2, 10, array("a", "b"));
```
## `randlogn(mu, sigma, row, col)`
声明：function
产生对数正态分布的随机数
| 参数 | 类型 | 说明 |
| ------- | -------------------------- | ---------------------------------- |
| `mu` | real | 对数正态分布参数，均值，实数类型 |
| `sigma` | real | 对数正态分布参数，标准差，实数类型 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randlogn(0, 1, 10, array("a", "b"));
```
## `randnbin(r, p, row, col)`
声明：function
产生负二项分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------------------- |
| `r` | integer | 试验成功的次数,为大于0的整数 |
| `p` | real | 一次试验成功的概率,为0,1之间的实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randnbin(10, 0.5, 10, array("a", "b"));
```
## `randnorm(mu, sigma, row, col)`
声明：function
产生正态分布的随机数
| 参数 | 类型 | 说明 |
| ------- | -------------------------- | ------------------------------ |
| `mu` | real | 正态分布参数，均值，实数类型 |
| `sigma` | real | 正态分布参数，标准差，实数类型 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randnorm(0, 1, 10, array("a", "b"));
```
## `randpoiss(lambda, row, col)`
声明：function
产生泊松分布的随机数
| 参数 | 类型 | 说明 |
| -------- | -------------------------- | ---------------------- |
| `lambda` | real | 分布参数,实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randpoiss(10, 10, array("a", "b"));
```
## `randrayl(b, row, col)`
声明：function
产生瑞利分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `b` | real | 分布参数,实数,缺省为1 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randrayl(1, 100, array("a", "b"));
```
## `randt(cv, row, col)`
声明：function
产生学生T分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `cv` | real | 学生T分布自由度,实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randt(30, 10, array("a", "b"));
```
## `randunid(n, row, col)`
声明：function
产生离散均匀分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `n` | integer | 分布参数,整数； |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randunid(10, 10, array("a", "b"));
```
## `randunif(a, b, row, col)`
声明：function
产生均匀分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `a` | real | 均匀分布的下限,实数 |
| `b` | real | 均匀分布的上限,实数 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randunif(1, 10, 10, array("a", "b"));
```
## `randwbl(a, b, row, col)`
声明：function
产生威布尔分布的随机数
| 参数 | 类型 | 说明 |
| ----- | -------------------------- | ---------------------- |
| `a` | real | 比例参数,实数,大于0 |
| `b` | real | 形状参数,实数,大于0 |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |
返回：any
### 示例
```tsl
return randwbl(1, 1.5, 100, array("a", "b"));
```
## `ratioValue(v1, v2)`
声明：function
比率（财务分析）
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |
返回：real
### 示例
```tsl
// 返回-1与-2的比率。
return ratioValue(-1, -2);
// 结果：-0.5
```
## `RatioValue_Math(v1, v2)`
声明：function
比率（数学分析）。针对除法计算处理，主要是对除0情况的考虑。
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `v1` | float | 实数。期末值 |
| `v2` | float | 实数。期初值 |
返回：float
## `readExcelSheets(alias, file_name, sheets_name, use_ole)`
声明：function
从Excel文件中读出Sheets列表。
| 参数 | 类型 | 说明 |
| ------------- | ---------- | -------------------------------------------------------------------------------- |
| `alias` | string | 字符串类型。参考目录别名。 |
| `file_name` | string | 字符串类型。文件名称。 |
| `sheets_name` | array | 返回值。存贮读出的SHEETS名称，存贮为一个一维字符串数组。 |
| `use_ole` | bool=false | 布尔型。是否使用Excel来读取，默认直接采用读文件的方式。设置为真则要求安装Excel。 |
返回：bool
### 示例
```tsl
// 读取本地文件的sheet列表名
rdo2 readExcelSheets('', 'd:\\test\\test.xls', r, 0);
return r;
// 结果：array("Sheet1","Sheet2","Sheet3")
```
## `Regress_AdjustedR2(r, t, k)`
声明：function
计算回归方程经调整的R平方，考虑由于加入新的解释变量而产生自由度的损失；
| 参数 | 类型 | 说明 |
| ---- | ---- | ----------------------------------- |
| `r` | any | 回归方程的拟合优度R平方，实数类型； |
| `t` | any | 样本的容量，整数类型； |
| `k` | any | 自变量的个数； |
返回：any
## `Regress_AicAndSbic(u, k, t)`
声明：function
信息准则函数，判断序列的最佳滞后阶数，分别计算AIC和SBIC统计量，并把结果赋值到一个一维数组，第一个是Aic值，第二个Sbic值。当选择最佳滞后阶数时，统计量越小越好。 AIC和SBIC的表达式如下所示： 其中：T为样本容量；k为自变量个数；u为残差；
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------------ |
| `u` | array | 回归方程的残差序列，为一维数组类型； |
| `k` | any | 解释变量的个数； |
| `t` | any | 样本的容量，整数类型； |
返回：array
## `Regress_Binary(y, x, extimation, methods, constant, alpha)`
声明：function
二元离散选择模型。返回结果有方程的系数、负2倍对数似然值和Wald检验（原假设为解释变量对被解释变量影响不显著，检验包含统计量、P值和原假设的值1表示接受原假设，0表示拒绝原假设）
| 参数 | 类型 | 说明 |
| ------------ | ------ | --------------------------------------------------------------- |
| `y` | array | 二元离散被解释变量序列，为一维数组类型 |
| `x` | array | 解释变量矩阵，每一列为一个解释变量，为二维数组类型 |
| `extimation` | string | 模型选择，字符串类型，"logit"或"probi" |
| `methods` | any | 0:单纯形法，1:转轴法,2:模式搜索法, 3:拟牛顿下山法,一般使用3方法 |
| `constant` | bool | object |
| `alpha` | float | 显著性水平，实数类型，取值在0-1之间，缺省时只输出模型的估计 |
返回：array
## `Regress_CMLS(y, x, u, constant)`
声明：function
线性回归方程的最小二乘法参数估计（可选择是否包含常数项），返回回归方程的系数，如果有常数项则排在第一项
| 参数 | 类型 | 说明 |
| ---------- | ----- | -------------------------------------------------- |
| `y` | array | 被解释变量序列，为一维数组类型 |
| `x` | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `u` | array | 残差序列，为一维数组类型，变参 |
| `constant` | bool | 是否包含常数项，为布尔类型，缺省为true |
返回：array
## `Regress_Constraint(y, x, constant, a, b, aeq, beq, alpha, options, lb, ub)`
声明：function
线性约束最小二乘回归
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------------------------------------- |
| `y` | array | 被解释变量序列，为一维数组类型，不可缺省 |
| `x` | array | 解释变量矩阵，为二维数组类型，每一列为一个自变量，不可缺省 |
| `constant` | bool | object |
| `a` | array | 不等式约束二维数字数组，不可缺省 |
| `b` | array | 不等式约束一维数字数组，不可缺省 |
| `aeq` | array | 等式约束二维数字数组 |
| `beq` | array | 等式约束一维数字数组 |
| `alpha` | float | 显著性水平，实数或整数，在0与1之间，缺省时只做参数的估计 |
| `options` | any | 方法选择: 0 残差平方和最小；1 方差最小 |
| `lb` | array | 下界约束一维数组 |
| `ub` | array | 上界约束一维数组 |
返回：array
## `Regress_domin_formula(y, x)`
声明：function
相对重要性分析-R2公式分解法 功能描述： 1、相对重要性分析 2、算法：根据含常数项的多元回归的r2的分解公式，来计算 不同解释变量的相对贡献度 3、公式法： 未考虑到不同解释变量之间的相互关系， 贡献度可能为负数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------- |
| `y` | array | Array of number,因变量 |
| `x` | array | Array of number,自变量 |
返回：array
## `Regress_domin_marginal(y, x, variable, option)`
声明：function
相对重要性分析-边际R2法 功能描述： 获取指定变量或所有变量的相对重要性分析， 与公式法相比，考虑了变量的相互关系，且贡献为正， 但是贡献度的和近似等于R2
| 参数 | 类型 | 说明 |
| ---------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y` | array | 因变量，被解释变量，是一维数字数组 |
| `x` | array | 自变量，解释变量，是二维数字数组 |
| `variable` | any | 指定变量，通过给X的列名，来指定单个变量，给nil时，表示所有变量【默认】 |
| `option` | any | 相对重要性的算法选择；1:利用包含指定变量回归中贡献度的均值计算【默认】，即平均R2边际效用法；0:利用完整回归中剔除其他变量的贡献度计算，即快速R2边际效用法 |
返回：array
## `Regress_DWTest(u)`
声明：function
德宾-沃森检验：检验随机误差项是否存在一阶自相关。结果返回DW统计量 DW统计量：（一般认为值在2附近，则随机误差项不存在自相关）
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `u` | array | 方程残差，为一维数组类型； |
返回：any
## `Regress_FTest(y, u, k, alpha)`
声明：function
在1-alpha的置信水平下，方程线性关系的置信检验：F检验；返回的结果是一个数组，第一个数为F统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） F-检验统计量： 其中：RSS是残差平方和，即； ESS是回归平方和，因变量的拟合值与因变量均值的差的平方，即； TSS是总平方和 TSS=RSS+ESS； 原假设：(为方程的系数)表示回归方程不显著；
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------------------------------- |
| `y` | array | 被解释变量序列，为一维数组类型； |
| `u` | array | 回归方程的残差序列，为一维数组类型； |
| `k` | any | 自变量的个数； |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格； |
返回：array
## `Regress_GRStest(alpha_values, residual_matrix, factor_matrix)`
声明：function
执行 GRS 检验。
| 参数 | 类型 | 说明 |
| ----------------- | ----- | ---------------------- |
| `alpha_values` | array | 截距项或 alpha 向量 |
| `residual_matrix` | array | 回归残差矩阵 |
| `factor_matrix` | array | 因子收益或因子暴露矩阵 |
返回：array
## `Regress_HettestSpearman(y, x, alpha, constant)`
声明：function
基于等级相关系数的异方差检验
| 参数 | 类型 | 说明 |
| ---------- | ----- | ------------------------------- |
| `y` | array | 数组，因变量，一维数字数组 |
| `x` | array | 数组，自变量，二维数字数组 |
| `alpha` | float | 实数，显著性水平，值域为\[0,1\] |
| `constant` | bool | object |
返回：array
## `Regress_JBTest(y, alpha)`
声明：function
在1-alpha的置信水平下，Jarque-Bera检验：检验y是否符合正态分布；返回一个数组，第一个数为Jarque-Bera统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受）； Jarque-Bera统计量： 其中：S、K分别表是随即变量的偏度和峰度；T：样本容量； Jarque-Bera统计量服从渐进的分布。 原假设：随机序列为正态分布
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------------------------------- |
| `y` | array | 随即序列，接受检验的序列，一维数组类型 |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格； |
返回：array
## `Regress_Logistic(y, x, constant, alpha)`
声明：function
logit二元离散选择模型。返回结果有方程的系数、负2倍对数似然值和Wald检验（原假设为解释变量对被解释变量影响不显著，检验包含统计量、P值和原假设的值1表示接受原假设，0表示拒绝原假设）
| 参数 | 类型 | 说明 |
| ---------- | ----- | -------------------------------------------------------------------------------------------------------------------------- |
| `y` | array | 因变量序列，为一维数组类型； |
| `x` | array | 自变量矩阵，为二维数组类型，每一列为一个自变量；自变量x的长度应小于等于因变量y，否则会报错，最好等于，若小于会对结果有影响 |
| `constant` | bool | object |
| `alpha` | float | 显著性水平，一般为5%，也有1%和10%，数值越小，判断越严格；默认为0.05 |
返回：array
## `Regress_MLS(y, x, u)`
声明：function
线性回归方程的最小二乘法参数估计（包含常数项），返回回归方程的系数，常数项排在第一项
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------------------------------- |
| `y` | array | 被解释变量序列，为一维数组类型 |
| `x` | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `u` | array | 残差序列，为一维数组类型，变参 |
返回：array
## `Regress_NLM(func, x, y, initial)`
声明：function
多元非线性回归，采用Marquardt方法求多元非线性方程的最小二乘回归系数。
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------------------------------- |
| `func` | string | 回归方程函数名，为字符串类型 |
| `x` | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `y` | array | 被解释变量序列，为一维数组类型 |
| `initial` | array | 估计参数初始值，一维数字数组 |
返回：array
## `Regress_pri(y, x, exps, alpha)`
声明：function
主成分回归，利用解释变量(Z 分数标准化)进行主成分分析降维得到的主成分，来对被解释变量(Z分数标准化)进行回归，进而消除多重共线性
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y` | array | 被解释变量序列，为一维数组类型 |
| `x` | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `exps` | float | 主成分累计贡献率，作为选取主成分数目的依据，当为小数时，代表累计贡献率的阀值，比如0.85，当为整数时，代表取的主成分的个数，比如2表示取前2个主成分。 |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |
返回：array
## `Regress_QRlsq(y, x, u, constant)`
声明：function
线性回归方程基于QR分解的最小二乘法参数估计（可选择是否包含常数项），返回回归方程的系数，如果有常数项则排在第一项
| 参数 | 类型 | 说明 |
| ---------- | ----- | ------------------------------------------------ |
| `y` | array | 因变量序列，为一维数组类型； |
| `x` | array | 自变量矩阵，为二维数组类型，每一列为一个自变量； |
| `u` | array | 残差序列，为一维数组类型； |
| `constant` | bool | object |
返回：array
## `Regress_Ridge(y_values, x_values, k_values, trace_mode)`
声明：function
执行岭回归，或按 `k_values` 输出岭迹。
| 参数 | 类型 | 说明 |
| ------------ | ----- | -------------------------------- |
| `y_values` | array | 因变量样本 |
| `x_values` | array | 自变量样本矩阵 |
| `k_values` | array | 可选。岭参数序列；省略时自动选择 |
| `trace_mode` | bool | 是否按岭迹模式输出 |
返回：array
## `Regress_RSquare(y, u, weight, dtype)`
声明：function
计算回归方程的拟合程度R平方，可适用与一元或多元的线性回归；
| 参数 | 类型 | 说明 |
| -------- | ----- | ------------------------------------ |
| `y` | array | 因变量序列，为一维数组类型； |
| `u` | array | 回归方程的残差序列，为一维数组类型； |
| `weight` | array | 一维数字数组,权重 |
| `dtype` | any | 整型,返回数据类型 |
返回：array
## `Regress_Stepwise(y, x, a_e, a_d)`
声明：function
逐步回归，默认的回归方程包含常数项，程序返回的结果:ret\["x"\]为筛选的变量的下标，ret\["regress"\]为筛选变量与因变量进行回归的结果。
| 参数 | 类型 | 说明 |
| ----- | ----- | ------------------------------------------------ |
| `y` | array | 因变量序列，为一维数组类型 |
| `x` | array | 自变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `a_e` | float | 选取变量的显著性水平，默认为0.05，为实数类型 |
| `a_d` | float | 剔除变量的显著性水平，默认为0.1，为实数类型 |
返回：array
## `Regress_TTest(x, a, u, k, alpha, constant)`
声明：function
在1-alpha的置信水平下，n元线性回归变量系数的置信检验：T检验；返回的结果是一个数组，第一个数为T统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） n元线性回归 T-检验统计量： 其中：为方程系数的估计，T为样本容量，k为自变量个数，X为常量加自变量的矩阵，其中； 原假设：（为方程的系数）表示回归方程不显著；
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------------------------------------------- |
| `x` | array | 变量矩阵，为二维数组类型，每一列为一个解释变量； |
| `a` | array | 回归系数，为一维数组类型； |
| `u` | array | 方程残差，为一维数组类型； |
| `k` | any | 自变量个数，为整数类型； |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格； |
| `constant` | bool | object |
返回：array
## `Regress_TTest_NW(x, a, u, alpha, constant, al, v_ols)`
声明：function
用NW调整对回归系数进行T检验。此调整用于当残差或者因变量（两者等价）存在异方差性并且存在自相关性时，利用OLS回归后对回归系数的协方差矩阵进行NW调整计算，得到每个系数NW调整后的标准误，再进行T检验。公式如下QNW=1Tt=1Tet2XtXt'+l=1Lt=l+1Twletet-lXtXt-l'+Xt-lXt' 其中，wl=1-l1+L 其中e为残差序列，Xi为X第i行的转置，L为自相关最大滞后阶数，Newey and West (1994)?提出可以用下面这个公式自动计算L=4\*(T100)2/9 之后代入下式计算出回归系数的协方差矩阵，它的对角元即为每个系数的方差Covβ\*=X'X-1X'σ2ΩXX'X-1=TX'X-1QNWX'X-1
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------------------------------------------------------------------------------------- |
| `x` | array | 二维数字数组, 自变量，不需要包含全1列 |
| `a` | array | 一维数字数组，回归系数, 有常数项回归时，a 为 常数项系数 union 自变量系数,；无常数项回归时，a 为 自变量系数 |
| `u` | array | 一维数字数组，残差序列，一维数字数组 |
| `alpha` | float | 实数，显著性水平，应为0到1之间的值，默认0.05 |
| `constant` | bool | object |
| `al` | any | 整数，自相关最大滞后阶数，可缺省，默认用Newey and West (1994)?提出的方法计算，至少为1 |
| `v_ols` | array | 二维数字数组，回归系数协方差矩阵，中间计算变量，无返回，但后续可以直接调用 |
返回：array
## `Regress_TTest_RWLS(x, a, u, k, alpha, constant, weight, restrictiveness)`
声明：function
T检验,在alpha的置信水平下，n元线性回归变量系数的显著性检验 原假设：回归方程系数不显著。带约束的加权最小二乘 RWLS 模型，对回归系数进行显著性检验， 适用于以下
| 参数 | 类型 | 说明 |
| ----------------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `x` | array | 一维数字数组,自变量矩阵，注意:含常数项的回归不需要给全1列 |
| `a` | array | 一维数字数组,方程系数；有常数项时，a 为 常数项系数 union 自变量系数；无常数项时，a 为 自变量系数 |
| `u` | array | 一维数字数组,残差序列 |
| `k` | any | 整型,自变量的个数；k = length(a)-constant；有常数项回归时，k := mcols(x);；无常数项回归，k := mcols(x)-1; |
| `alpha` | float | 实数,显著性水平 |
| `constant` | bool | Bool,是否为含常数项回归 |
| `weight` | array | 数组,加权回归的权重，默认等权重 |
| `restrictiveness` | array | 数组,线性约束，只需要给对应于回归系数个数长度的一维数组，默认无约束；例如:有5个系数，分别为x0,x1,x2,x3,x4；约束为: x1+x2+3x4=3；则所给的参数为:；array(0,1,1,0,3) |
返回：array
## `Regress_TTest_White(x, a, u, alpha, constant, v_ols)`
声明：function
用White调整对回归系数进行T检验。此调整用于当残差或者因变量（两者等价）存在异方差性但不存在自相关性时，利用OLS回归后对回归系数的协方差矩阵进行White调整计算，得到每个系数White调整后的标准误，再进行T检验。公式如下QWhite=1Ti=1Tei2XiXi' 其中e为残差序列，Xi为X第i行的转置 之后代入下式计算出回归系数的协方差矩阵，它的对角元即为每个系数的方差Covβ\*=X'X-1X'σ2ΩXX'X-1=TX'X-1QWhiteX'X-1
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------------------------------------------------------------------------------------- |
| `x` | array | 二维数字数组, 自变量，不需要包含全1列 |
| `a` | array | 一维数字数组，回归系数, 有常数项回归时，a 为 常数项系数 union 自变量系数,；无常数项回归时，a 为 自变量系数 |
| `u` | array | 一维数字数组，残差序列，一维数字数组 |
| `alpha` | float | 实数，显著性水平，应为0到1之间的值，默认0.05 |
| `constant` | bool | object |
| `v_ols` | array | 二维数字数组，回归系数协方差矩阵，中间计算变量，无返回，但后续可以直接调用 |
返回：array
## `Regress_VIF(x)`
声明：function
x的多重共线性分析，输出方差扩大因子VIF指标和条件数，一般VIF大于10，表明存在严重的多重共线性；5<VIF<10,表明存在多重共线性；如果VIF小于5的话，表明这种回归模型的多重共线性可以接受。用条件数判断多重共线性的准则 0<k<10时,设计矩阵X没有多重共线性; 10≤k<100时,认为X存在较强的多重共线性; 当k≥100时,则认为存在严重的多重共线性。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------- |
| `x` | array | 数据，每一列是一个指标 |
返回：array
## `Regress_VIFR2(x, w, constant)`
声明：function
vif分析增强
| 参数 | 类型 | 说明 |
| ---------- | ---- | ------------- |
| `x` | any | 表达式,自变量 |
| `w` | any | 表达式,权重 |
| `constant` | bool | object |
返回：array
## `Regress_White(y, x, crr, alpha)`
声明：function
包含无交叉项和交叉项两种，用于检验回归方程的异方差性，原假设为不存在异方差（Hypothesis的值0表示拒绝，1表示接受）
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------------------------------- |
| `y` | array | 被解释变量，为一维数组类型 |
| `x` | array | 解释变量，为二维数组类型 |
| `crr` | any | 交叉项，0为无交叉项，1为有交叉项 |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格； |
返回：array
## `Regress_WLS(y_values, x_values, weights, residuals)`
声明：function
执行加权最小二乘回归并输出残差。
| 参数 | 类型 | 说明 |
| ----------- | ----- | ------------ |
| `y_values` | array | 因变量样本 |
| `x_values` | array | 自变量样本 |
| `weights` | array | 权重序列 |
| `residuals` | any | 接收残差序列 |
返回：array
## `regression(y, x, alpha, constant, options)`
声明：function
线性回归方程的最小二乘法参数估计及检验（可选择是否包含常数项），返回结果有回归系数、R平方、调整R平方、残差序列、残差检验、F检验、T检验、DW统计量和信息准则
| 参数 | 类型 | 说明 |
| ---------- | ---------------- | ---- |
| `y` | array,tablearray | |
| `x` | array,tablearray | |
| `alpha` | real | |
| `constant` | bool | |
| `options` | array,tablearray | |
返回：array,tablearray
### 示例
```tsl
y := array(0.001, 0.564, 0.193, 0.809, 0.585, 0.48, 0.35, 0.896, 0.823, 0.747);
x := array(
(0.174, 0.859),
(0.711, 0.514),
(0.304, 0.015),
(0.091, 0.364),
(0.147, 0.166),
(0.989, 0.446),
(0.119, 0.005),
(0.009, 0.378),
(0.532, 0.571),
(0.602, 0.607));
// u作为变参返回
return regression(y, x, 0.05, 1);
```
## `Regression_OLS_NW(y, x, constant, alpha, al)`
声明：function
NW调整的OLS回归，此调整用于当残差或者因变量（两者等价）存在异方差性并且自相关性时，利用OLS回归后对回归系数的协方差矩阵进行NW调整计算，得到每个系数White调整后的标准误，再进行T检验。T检验部分相关公式详见Regress_TTest_NW，回归系数的OLS解如下β\*=(X'X)-1X'y 其余部分定义与普通最小二乘OLS一致
| 参数 | 类型 | 说明 |
| ---------- | ----- | ------------------------------------------------------------------------------------- |
| `y` | array | 一维数字数组, 因变量 |
| `x` | array | 二维数字数组, 自变量，不需要包含全1列 |
| `constant` | bool | object |
| `alpha` | float | 实数，显著性水平，应为0到1之间的值，默认0.05 |
| `al` | any | 整数，自相关最大滞后阶数，可缺省，默认用Newey and West (1994)?提出的方法计算，至少为1 |
返回：array
## `Regression_OLS_White(y, x, constant, alpha)`
声明：function
White调整的OLS回归，此调整用于当残差或者因变量（两者等价）存在异方差性但不存在自相关性时，利用OLS回归后对回归系数的协方差矩阵进行White调整计算，得到每个系数White调整后的标准误，再进行T检验。T检验部分相关公式详见Regress_TTest_White，回归系数的OLS解如下β\*=(X'X)-1X'y 其余部分定义与普通最小二乘OLS一致
| 参数 | 类型 | 说明 |
| ---------- | ----- | -------------------------------------------- |
| `y` | array | 一维数字数组, 因变量 |
| `x` | array | 二维数字数组, 自变量，不需要包含全1列 |
| `constant` | bool | object |
| `alpha` | float | 实数，显著性水平，应为0到1之间的值，默认0.05 |
返回：array
## `Regression_WLS(y, x, alpha, constant, wtype, m1, m2, steps, wweight)`
声明：function
加权最小二乘法回归, WType为0时，必须给出m1 权重系数下限，m2 权重系数上限，steps 步长，用于计算最优权重，WType为1时，必须给出wweight权重向量。
| 参数 | 类型 | 说明 |
| ---------- | ----- | --------------------------------------------------------------------- |
| `y` | array | 因变量，一维数字数组 |
| `x` | array | 自变量，二维数字数组 |
| `alpha` | float | 显著性水平,实数 |
| `constant` | bool | object |
| `wtype` | bool | object |
| `m1` | float | 权重系数下限，实数 |
| `m2` | float | 权重系数上限，实数 |
| `steps` | float | 步长，实数 |
| `wweight` | array | 权重向量，一维数字数组，当WType设置为1时，需要此参数的输入；返回结果: |
返回：array
## `regressionChannel(y, x, nowy, nowx, beta, alpha, top_alpha, bottom_alpha, top, bottom, pos, expectvalue)`
声明：function
回归通道模型。
| 参数 | 类型 | 说明 |
| -------------- | ----- | ----------------------- |
| `y` | array | 一维数字数组，Y坐标数组 |
| `x` | array | 一维数字数组，X坐标数组 |
| `nowy` | real | 实数 |
| `nowx` | real | 实数 |
| `beta` | real | 实数 |
| `alpha` | real | 实数 |
| `top_alpha` | real | 实数 |
| `bottom_alpha` | real | 实数 |
| `top` | real | 实数 |
| `bottom` | real | 实数 |
| `pos` | real | 实数 |
| `expectvalue` | real | 实数，预期值(回归值) |
返回：real
### 示例
```tsl
regressionChannel(array(1, 2, 3, 4, 5), array(6, 7, 8, 9, 10), 1, 2, 3, 4, 5, 6, 7, 8, s, a);
return a;
// 返回：-3
```
## `reIndex2(data, flag)`
声明：function
修改数组的行标或列名，主要用于字符串下标修改为数字下标等
| 参数 | 类型 | 说明 |
| ------ | ---------------- | ---- |
| `data` | array,tablearray | |
| `flag` | integer | |
返回：array,tablearray
### 示例
范例数据表：a := array('C':('A':1,'B':'too'),'D':('A':2,'B':'two'));
```tsl
// 其显示如下：
```
范例一：将表列标改为数字
```tsl
a := array('C': ('A': 1, 'B': 'too'), 'D': ('A': 2, 'B': 'two'));
return reIndex2(a, 0);
```
范例二：将行列标作为首列首行
```tsl
a := array('C': ('A': 1, 'B': 'too'), 'D': ('A': 2, 'B': 'two'));
return reIndex2(a, 5);
```
## `Robustfit_M(y, x, alpha, constant, wfun, tune, options)`
声明：function
基于M估计的稳健回归及其检验
| 参数 | 类型 | 说明 |
| ---------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y` | array | 一维数字数组，因变量 |
| `x` | array | 二维数字数组，自变量 |
| `alpha` | float | 实数，显著性水平 |
| `constant` | bool | object |
| `wfun` | string | 字符串，权重函数 |
| `tune` | float | 实数，调节常数 |
| `options` | array | 可选。为数组类型，格式为array( 'maxiter':最大迭代次数, 'tol':标准误差, 'ifregtest':是否返回回归检验)，默认值为array('maxiter':50, 'tol':1e-6, 'ifregtest':True)。其中'maxiter'、'tol'与迭代优化相关，分别表示最大迭代次数与相邻两次迭代的标准误差；'ifregtest'是布尔类型，控制输出结果是否返回回归检验，若为真，其回归检验指标使用加权最小二乘的回归检验，可参考Regression_WLS。 |
返回：array
## `roots(p)`
声明：function
一元n次方程求根
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `p` | array | array 多项式 |
返回：array
### 示例
```tsl
// 求根：3x^3+x^2+x^1+0^0=0
return roots(array(0, 1, 1, 3));
```
## `rotatedComponentMatrix(cm)`
声明：function
返回方差最大正交旋转矩阵
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `cm` | array | 二维数字数组类型，载荷矩阵 |
返回：array
### 示例
```tsl
// 设置样本矩阵
zt := array((0.7592, 1.7593, 21.9279, 48.5626, 55.1679),
(0.0490, 0.4457, 2.2255, 82.2658, 192.4348),
(-2.2313, -1.3096, -59.8883, 3.9922, -80.2419),
(0.1364, 0.539, 4.3910, 55.1438, 46.0612),
(0.7233, 1.9467, 15.6127, 111.3018, 58.3969));
z_t_s := Standarize_II(z_t); // 标准化
mt_Transposition(z_t_s, z); // 转置
r := correlationMatrix(z); // 相关系数矩阵
Eigen_Jacobi(r, eigen_value, eigen_vector); // 特征值&特征向量
cm := componentMatrix(eigen_value, eigen_vector, max_eigen_value); // 载荷矩阵
return rotatedComponentMatrix(cm);
```
## `safeEval(exp)`
声明：function
表达式求值
| 参数 | 类型 | 说明 |
| ----- | ----------- | ---------- |
| `exp` | texpression | 表达式类型 |
返回：any
## `safeSetSysParam(systype, value)`
声明：function
设置系统参数。主要是将value的值转化为正确的对应于systype数据类型，再通过setsysparam进行设置setysparam(systype,value)，保证系统参数设置成功。
| 参数 | 类型 | 说明 |
| --------- | ------ | ------------------------ |
| `systype` | string | 字符串，系统参数名称 |
| `value` | real | 实数或字符串，系统参数值 |
返回：integer
## `selfStdDev(t, rmar)`
声明：function
下方标准差。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------------------------------- |
| `t` | array | 数据表类型，一维数据 |
| `rmar` | real | 实数，最低可接受的收益率(已折算过) |
返回：real
### 示例
```tsl
return selfStdDev(array(1, 2, 3, 4, 5), 3);
// 返回：0.89
```
## `setHttpAcceptencoding(session, acceptencodingstr)`
声明：function
设定压缩格式编码类型。
| 参数 | 类型 | 说明 |
| ------------------- | ------ | ------------------- |
| `session` | comobj | session ID |
| `acceptencodingstr` | string | Accept-Encoding类型 |
返回：any
### 示例
```tsl
url := "http://www.baidu.com";
sid := createHttpSession();
setHttpAcceptencoding(sid, "gzip"); // 设定压缩格式编码类型
setHttpCallBack(sid, findfunction("DownProg01")); // 进度回调
r := getHttp(url, 60000, v, code);
echo "\r\nDone", '->code:', code, '->返回内容总长度:', length(v), "\r\n";
return 0;
// --------------进度回调函数---------------------
function DownProg01(sid, alldn_b, dn_b, allup_b, up_b); // progresscallback-不提前结束
begin
if dn_b > 0 then // 如果大于0则打印
begin
echo "AlldnB:", alldn_b, ",dnB:", dn_b, ",AllupB:", allup_b, ",upB:", up_b, "\r\n";
end;
return 0; // not done
end;
// 打印结果：
// 注：当http进度回调时，当服务器使用分块传输（启用压缩通常会使用分块传输）时， 无法预先知道总大小所以可能出现为0的情况，属于正常现象。
```
## `setHttpAcceptencodingon(session, is_zip)`
声明：function
设定是否支持压缩。
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------- |
| `session` | comobj | session ID |
| `is_zip` | bool | 是否支持压缩传输，默认支持 |
返回：any
### 示例
```tsl
url := "http://www.baidu.com";
sid := createHttpSession();
setHttpAcceptencodingon(sid, false); // 设定为不允许压缩传输
setHttpCallBack(sid, findfunction("DownProg01")); // 进度回调
r := getHttp(url, 60000, v, code);
echo "\r\nDone", '->code:', code, '->返回内容总长度:', length(v), "\r\n";
return 0;
// --------------进度回调函数---------------------
function DownProg01(sid, alldn_b, dn_b, allup_b, up_b); // progresscallback-不提前结束
begin
if dn_b > 0 then // 如果大于0则打印
begin
echo "AlldnB:", alldn_b, ",dnB:", dn_b, ",AllupB:", allup_b, ",upB:", up_b, "\r\n";
end;
return 0; // not done
end;
// 打印信息如下：
```
## `sf_betacdf(x, a, b, v)`
声明：function
贝塔分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | beta分布参数1,实数,大于0 |
| `b` | float | beta分布参数2,实数,大于0 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_betainv1(y, a, b)`
声明：function
贝塔分布的分布逆函数，输入分布函数值，返回随机变量值。功能与sf_betainv一致，输出接口不一样。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------------------------------- |
| `y` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a` | float | beta分布参数1,实数,大于0 |
| `b` | float | beta分布参数2,实数,大于0 |
返回：array
## `sf_betapdf(x, a, b, v)`
声明：function
贝塔分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | beta分布参数1,实数,大于0 |
| `b` | float | beta分布参数2,实数,大于0 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_binocdf(x, n, p, v)`
声明：function
二项分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n` | any | 试验总量,为大于0的整数； |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_binoinv(y, n, p, x)`
声明：function
二项分布的分布逆函数，输入累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `n` | any | 试验总量,为大于0的整数； |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_binopdf(x, n, p, v)`
声明：function
二项分布的概率函数，输入随机变量，返回随机变量对应的概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n` | any | 试验总量,为大于0的整数； |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_Cauchycdf(x, a, b, v)`
声明：function
柯西的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 位置参数,实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_Cauchyinv(y, a, b, x)`
声明：function
柯西的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a` | float | 位置参数,实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_Cauchypdf(x, a, b, v)`
声明：function
柯西的概率密度函数，输入随机变量，返回随机变量对应的概率密度
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 位置参数,实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_ch2cdf(x, cv, v)`
声明：function
卡方分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 卡方分布自由度,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_ch2inv(y, cv, x, return_value)`
声明：function
卡方分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| -------------- | ----- | ----------------------------------------------------------- |
| `y` | any | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 卡方分布自由度,实数 |
| `x` | any | 可选。输出参数，随机变量值，类型和y一样 |
| `return_value` | any | 返回随机变量值，类型和y一样 |
返回：array
## `sf_ch2pdf(x, cv, v)`
声明：function
卡方分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 卡方分布自由度,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_copulacdf(x, copula_type, rho, alpha, options)`
声明：function
估计多元函数分布值
| 参数 | 类型 | 说明 |
| ------------- | ------ | -------------------------------------------------------------------------------------------------------------------- |
| `x` | array | 数组，样本值为均匀分布需要在\[0,1\]区间内，至少2维 |
| `copula_type` | string | 字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维 |
| `rho` | array | 数组，相关系数矩阵，d\*d |
| `alpha` | float | 实数，参数估计值，t分布时为自由度，二元阿基米德分布时为估值参数,默认1;；clayton:\[0,∞)； frank:(-∞,∞)；gumbel:\[1,∞) |
| `options` | array | 数组，估计规划条件，可为空 |
返回：array
## `sf_copulafit(x, copula_type, method, options)`
声明：function
估计多元分布相关系数矩阵
| 参数 | 类型 | 说明 |
| ------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------- |
| `x` | array | 数组，样本值为均匀分布需要在\[0,1\]区间内，至少2维 |
| `copula_type` | string | 字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维 |
| `method` | string | 字符串，极大似然估计方法(多元分布时有效)；ML —最大似然估计 （默认）；AML —调整的似然估计，性能上比MLE快，但不适用于中小样本量 |
| `options` | array | 数组，估计规划条件，可为空 |
返回：array
## `sf_exp(x, mu, v)`
声明：function
指数分布累计概率
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------------------------- |
| `x` | array | 随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 分布参数 |
| `v` | array | 返回值 |
返回：array
## `sf_expinv(y, mu, x)`
声明：function
指数分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 分布参数,实数,缺省为1 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_fcdf(x, v1, v2, v)`
声明：function
F分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `v1` | float | 分子自由度,大于0的实数 |
| `v2` | float | 分母自由度,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_finv1(y, v1, v2, x)`
声明：function
F分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------------------------------- |
| `y` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `v1` | float | 分子自由度,大于0的实数 |
| `v2` | float | 分母自由度,大于0的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：array
## `sf_fpdf(x, v1, v2, v)`
声明：function
F分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `v1` | float | 分子自由度,大于0的实数 |
| `v2` | float | 分母自由度,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_gamcdf(x, a, b, v)`
声明：function
伽马分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 形状参数,大于0的实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_gaminv(y, a, b, x)`
声明：function
伽马分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a` | float | 形状参数,大于0的实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_gampdf(x, a, b, v)`
声明：function
伽马分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 形状参数,大于0的实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_geocdf(x, p, v)`
声明：function
几何分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `p` | float | p:一次试验成功的概率,为0,1之间的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_geoinv(y, p, x)`
声明：function
几何分布的分布逆函数，输入累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_geopdf(x, p, v)`
声明：function
几何分布的概率函数，输入随机变量，返回随机变量对应的概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_hygecdf(x, m, k, n, v)`
声明：function
超几何分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `m` | any | 总体数目,非负整数 |
| `k` | any | 总体标数目,非负整数 |
| `n` | any | 抽样数目,非负整数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_hygeinv(y, m, k, n, x)`
声明：function
超几何分布的分布逆函数，输入累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `m` | any | 总体数目,非负整数 |
| `k` | any | 总体标数目,非负整数 |
| `n` | any | 抽样数目,非负整数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_hygepdf(x, m, k, n, v)`
声明：function
超几何分布的概率函数，输入随机变量，返回随机变量对应的概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `m` | any | 总体数目,非负整数 |
| `k` | any | 总体标数目,非负整数 |
| `n` | any | 抽样数目,非负整数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_Laplacecdf(x, mu, b, v)`
声明：function
拉普拉斯的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 位置参数,实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_Laplaceinv(y, mu, b, x)`
声明：function
拉普拉斯的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 位置参数,实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_Laplacepdf(x, mu, b, v)`
声明：function
拉普拉斯的概率密度函数，输入随机变量，返回随机变量对应的概率密度
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 位置参数,实数 |
| `b` | float | 尺度参数,大于0的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_logncdf(x, mu, sigma, v)`
声明：function
对数正态分布的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值
| 参数 | 类型 | 说明 |
| ------- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 对数正态分布参数，均值，实数类型 |
| `sigma` | float | 对数正态分布参数，标准差，实数类型 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_logninv(y, mu, sigma, x)`
声明：function
对数正态分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ------- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 对数正态分布参数，均值，实数类型 |
| `sigma` | float | 对数正态分布参数，标准差，实数类型 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_lognpdf(x, mu, sigma, v)`
声明：function
对数正态分布的概率密度函数，输入随机变量，返回随机变量对应的概率密度
| 参数 | 类型 | 说明 |
| ------- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 对数正态分布参数，均值，实数类型 |
| `sigma` | float | 对数正态分布参数，标准差，实数类型 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_mvncdf(lower_bounds, upper_bounds, mean_values, correlation_matrix)`
声明：function
计算多变量正态分布累计分布值。
| 参数 | 类型 | 说明 |
| -------------------- | ----- | ------------------------------- |
| `lower_bounds` | array | 下界；传 `nil` 表示使用默认下界 |
| `upper_bounds` | array | 上界矩阵 |
| `mean_values` | array | 均值；传 `nil` 表示使用默认均值 |
| `correlation_matrix` | array | 相关系数矩阵 |
返回：array
## `sf_mvtcdf(lower_bounds, upper_bounds, correlation_matrix, degrees_freedom)`
声明：function
计算多变量 t 分布累计分布值。
| 参数 | 类型 | 说明 |
| -------------------- | ----- | ------------------------------- |
| `lower_bounds` | array | 下界；传 `nil` 表示使用默认下界 |
| `upper_bounds` | array | 上界矩阵 |
| `correlation_matrix` | array | 相关系数矩阵 |
| `degrees_freedom` | float | 自由度 |
返回：array
## `sf_nbincdf(x, r, p, v)`
声明：function
负二项分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `r` | any | 试验成功的次数,为大于0的整数 |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_nbininv(y, r, p, x)`
声明：function
负二项分布的分布逆函数，输入累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `r` | any | 试验成功的次数,为大于0的整数 |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_nbinpdf(x, r, p, v)`
声明：function
负二项分布的概率函数，输入随机变量，返回随机变量对应的概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `r` | any | 试验成功的次数,为大于0的整数 |
| `p` | float | 一次试验成功的概率,为0,1之间的实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_normcdf(x, mu, sigma, v)`
声明：function
计算随机变量在正态分布, 均值为mu，方差为sigma条件下的分布函数,返回分布函数值。
| 参数 | 类型 | 说明 |
| ------- | ----- | ----------------------------------------------- |
| `x` | array | :随机变量，可以是实数，也可以是一个实数二维数组 |
| `mu` | float | 正态分布的均值，实数类型 |
| `sigma` | float | 正态分布的标准差，大于0的实数 |
| `v` | array | 变参返回x对应的正态分布函数的值，实数或二维数组 |
返回：any
## `sf_norminv(y, mu, sigma, x)`
声明：function
正态分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ------- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 正态分布参数，均值，实数类型 |
| `sigma` | float | 正态分布参数，标准差，实数类型 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_normpdf(x, mu, sigma, v)`
声明：function
正态分布的概率密度函数，输入随机变量，返回随机变量对应的概率密度
| 参数 | 类型 | 说明 |
| ------- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 正态分布参数，均值，实数类型 |
| `sigma` | float | 正态分布参数，标准差，实数类型 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_poisscdf(x, lambda, v)`
声明：function
泊松分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| -------- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `lambda` | float | 分布参数,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_poissinv(y, lambda, x)`
声明：function
泊松分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| -------- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `lambda` | float | 分布参数,实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_poisspdf(x, lambda, v)`
声明：function
泊松分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| -------- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `lambda` | float | 分布参数,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_raylcdf(x, b, v)`
声明：function
瑞利分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `b` | float | 分布参数,实数,缺省为1 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_raylinv(y, b, x)`
声明：function
瑞利分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `b` | float | 分布参数,实数,缺省为1 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_raylpdf(x, b, v)`
声明：function
瑞利分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `b` | float | 分布参数,实数,缺省为1 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_tcdf(x, cv, v)`
声明：function
学生T分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 学生T分布自由度,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_tinv1(y, cv, x)`
声明：function
学生T分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 学生T分布自由度,实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_tpdf(x, cv, v)`
声明：function
学生T分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 学生T分布自由度,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_unidcdf(x, n, v)`
声明：function
离散均匀分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n` | any | 分布参数,整数； |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_unidinv(y, n, x)`
声明：function
离散均匀分布的分布逆函数，输入累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `n` | any | 分布参数,整数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_unidpdf(x, n, v)`
声明：function
离散均匀分布的概率函数，输入随机变量，返回随机变量对应的概率
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n` | any | 分布参数,整数； |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_unifcdf(x, a, b, v)`
声明：function
均匀分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 均匀分布的下限,实数 |
| `b` | float | 均匀分布的上限,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_unifinv(y, a, b, x)`
声明：function
均匀分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a` | float | 均匀分布的下限,实数 |
| `b` | float | 均匀分布的上限,实数 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_unifpdf(x, a, b, v)`
声明：function
均匀分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 均匀分布的下限,实数 |
| `b` | float | 均匀分布的上限,实数 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_wblcdf(x, a, b, v)`
声明：function
威布尔分布的分布函数，输入随机变量，返回随机变量对应的分布函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 比例参数,实数,大于0 |
| `b` | float | 形状参数,实数,大于0 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `sf_wblinv(y, a, b, x)`
声明：function
威布尔分布的分布逆函数，输入分布函数值，返回随机变量值
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------- |
| `y` | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a` | float | 比例参数,实数,大于0 |
| `b` | float | 形状参数,实数,大于0 |
| `x` | array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
## `sf_wblpdf(x, a, b, v)`
声明：function
威布尔分布的密度函数，输入随机变量，返回随机变量对应的密度函数值
| 参数 | 类型 | 说明 |
| ---- | ----- | --------------------------------------------- |
| `x` | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a` | float | 比例参数,实数,大于0 |
| `b` | float | 形状参数,实数,大于0 |
| `v` | array | 变参返回，该函数也支持直接返回，类型和x一样 |
返回：any
## `SingleLinearRegression_CallBack(x)`
声明：function
单元线性回归的回调函数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 二维数字数组类型 |
返回：array
## `SingleLineralRegression_Pgm(x, y)`
声明：function
单元线性回归测试
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 一维数字数组类型 |
| `y` | array | 一维数字数组类型 |
返回：array
## `singleRegression(x, y, call_back)`
声明：function
单元回归
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------------------- |
| `x` | array | 一维数字数组类型，观察数据点 |
| `y` | array | 一维数字数组类型，观察数据值 |
| `call_back` | string | 字符串，计算系数矩阵的回调 |
返回：array
### 示例
```tsl
x := array(0.00, 1.00, 2.00);
y := array(1.00, 2.00, 3);
call_back := 'SingleLinearRegression_CallBack';
return singleRegression(x, y, call_back);
```
## `SingleUnLineralRegression_CallBack(x)`
声明：function
单元非线性回归的回调函数
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 一维数字数组类型 |
返回：array
## `SingleUnLineralRegression_Pgm(x, y)`
声明：function
单元非线性回归测试
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 一维数字数组类型 |
| `y` | array | 一维数字数组类型 |
返回：array
## `singleVariableExecute(arr, sys_name, exp)`
声明：function
设置系统变量SysName的值为Arr中的元素，执行表达式exp，将表达式的值放到数组Arr中。
| 参数 | 类型 | 说明 |
| ---------- | ----------- | ------------------------ |
| `arr` | array | 数组， |
| `sys_name` | string | 字符串，指定系统参数名称 |
| `exp` | texpression | 表达式 |
返回：array
### 示例
```tsl
// Arr中存储的是代码，获取2019年3月1日，Arr中所有代码的收盘价
arr := array('SZ000001', 'SZ000002');
return singleVariableExecute(arr, pn_stock(), @close());
```
## `skew(t, skew)`
声明：function
偏斜度。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------------------- |
| `t` | array | 一维数字数组，一维数据 |
| `skew` | real | 实数，返回的偏斜度 |
返回：any
### 示例
```tsl
skew(array(1, 2, 3, 4, 5, 7), s);
return s;
// 返回：0.46
```
## `spline(x1, y1, xx1)`
声明：function
三次样条插值
| 参数 | 类型 | 说明 |
| ----- | ----- | ----------------------- |
| `x1` | array | 一维数字数组 横坐标序列 |
| `y1` | array | 一维数字数组 纵坐标序列 |
| `xx1` | array | 实数或一维数字数组 插值 |
返回：array
### 示例
```tsl
x := array(5, 1, 19, 8);
y := array(2, 3, 1, 7);
xx := array(4, 12);
return spline(x, y, xx);
// 返回：array(1.1407,13.9444)
```
## `Standarize_II(sample, leib)`
声明：function
数据预处理，对二维数字数组进行标准化化处理；行：样本个数;列：因子个数.
| 参数 | 类型 | 说明 |
| -------- | ----- | ----------------- |
| `sample` | array | 二维数字数组 样本 |
| `leib` | any | Int 标准化类型 |
返回：array
## `SUMT_Method(x0, call_back)`
声明：function
SUMT法求解有约束最优化问题
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------------------------- |
| `x0` | array | 一维数字数组类型，各个变量的初始值 |
| `call_back` | string | 字符串类型，计算目标值的回调 |
返回：array
## `Sumt_Method__Pgm()`
声明：function
Sumt算法测试
返回：array
## `Sumt_Method_CallBack(x, r)`
声明：function
Sumt算法回调
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `x` | array | 一维数字数组类型 |
| `r` | float | 实数类型 |
返回：float
## `sysGetMemoryUsage()`
声明：function
获取系统内存状态
返回：array,tablearray
### 示例
```tsl
// 获得系统内存状态
return sysGetMemoryUsage();
```
## `sysGetPidOfCom(obj)`
声明：function
取得 COM 对象对应的进程 ID。
| 参数 | 类型 | 说明 |
| ----- | ------ | ---------- |
| `obj` | comobj | COM 对象。 |
返回：integer
### 示例
范例01：基本用法
```tsl
getOleObject("Word.Application", 0, obj);
pid := sysGetPidOfCom(obj);
echo pid > 0, "\n";
// 输出：1
```
## `sysGetPidTidOfWnd(wnd[, var thread_id])`
声明：function
取得窗口句柄对应的进程 ID，并可通过输出参数取得线程 ID。
| 参数 | 类型 | 说明 |
| ----------- | ------- | --------------------------- |
| `wnd` | hwnd | 窗口句柄。 |
| `thread_id` | integer | 可选输出参数，写回线程 ID。 |
返回：integer
### 示例
范例01：基本用法
```tsl
windows := sysGetWndOfCaption("Untitled - Notepad", true);
if length(windows) > 0 then
begin
pid := sysGetPidTidOfWnd(windows[0], thread_id);
echo pid > 0 and thread_id > 0, "\n";
// 输出：1
end
```
## `sysGetProcessMemoryUsage(pid)`
声明：function
获取进程的内存使用状态
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------------------------------------- |
| `pid` | integer | 整数，可选参数，进程ID。未指定时默认获取自身的内存使用状态 |
返回：array
### 示例
```tsl
// 获得自身的内存使用状态
return sysGetProcessMemoryUsage();
```
## `sysGetWndOfCaption(caption[, is_contain_string])`
声明：function
按窗口标题查找窗口句柄列表。is_contain_string 可省略，缺省为真。
| 参数 | 类型 | 说明 |
| ------------------- | ------- | ---------------------------------------- |
| `caption` | string | 窗口标题。 |
| `is_contain_string` | boolean | 可选；是否按标题包含关系匹配，缺省为真。 |
返回：array of hwnd
### 示例
范例01：基本用法
```tsl
windows := sysGetWndOfCaption("Untitled - Notepad", true);
echo ifArray(windows), "\n";
// 输出：1
```
## `sysLibCVersion()`
声明：function
获取系统中C语言支持库的版本
返回：string
### 示例
```tsl
// 获得C语言支持库的版本
return sysLibCVersion();
// 返回："10.0.26100.8521"
```
## `Time_ACF(y)`
声明：function
自相关系数，计算随机序列与所有滞后阶数的相关系数。
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------------------------------------------------------------- |
| `y` | array | 数组，样本序列；；p:整数，返回样本自相关系数序列的长度，默认值为3，允许缺省； |
返回：array
## `Time_Analyse(y, model, p, q, l)`
声明：function
ARMA模型分析，时间序列的ARMA模型分析，可以自动的选择q与p
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------------------------- |
| `y` | array | 样本序列，为一维数组类型； |
| `model` | string | 模型类别为AR、MA、ARMA，为字符串类型； |
| `p` | any | 自回归阶数，取0则自动选择阶数，为整数类型； |
| `q` | any | 移动平均阶数，取0则自动选择阶数，为整数类型； |
| `l` | any | 预测步长，为整型类型； |
返回：any
## `Time_ARCH(r_series, q, l)`
声明：function
自回归条件异方差模型，本模型的ARCH模型如下： sss 可把异方差方程进行整合，得到 用最小二乘法去估计方程的系数了，得到系数的相合估计。 或者用最大似然估计去估计参数，得到精度估计，最大似然估计的目标函数值为：
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------- |
| `r_series` | array | 资产收益率，为一维数组类型； |
| `q` | any | 自回归阶数，为整数类型； |
| `l` | any | 预测步长，为整数类型 |
返回：array
## `Time_ARCHTest(u, q, alpha)`
声明：function
时间序列异方差的ARCH检验，原假设都为没有异方差，即不存在ARCH效应，Hypothesis为1表示接受原假设，0表示拒绝原假设 检验统计量为： 对方程进行估计，得到F统计量和T×R2统计量并进行检验；
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------------------------------- |
| `u` | array | 残差序列，为一维数组类型 |
| `q` | any | 滞后阶数，为整数类型 |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格 |
返回：array
## `Time_ARMA(y, p, q, l)`
声明：function
建议使用ARMA模型替换，自回归移动平均模型，ARMA(p,q)模型，采用逆函数去估计自回归系数和移动平均系数，返回结果有自回归系数、移动平均系数、残差方差、预测值及预测波动。 估计过程如下： ，为自协方差 其中：yt为原序列零均值化的新序列，μ为原序列的均值，ρp是自相关系数，φq是自回归方程系数，θq为移动平均系数，εt是零均值、方差为σ2的平稳白噪声
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `y` | array | 样本序列，为一维数组类型； |
| `p` | any | 自回归阶数； |
| `q` | any | 移动平均阶数 |
| `l` | any | 预测步长，整数 |
返回：array
## `Time_ARp(y, p, l)`
声明：function
建议使用AR模型替换，自回归模型，AR(p)模型，用Yule-Walker方程去估计p阶自回归模型的系数，返回结果有自回归系数、残差方差、预测值及预测波动。估计过程如下 AR(p)模型： 如有常数项，则 ，为自协方差 其中：为原序列零均值化的新序列，为原序列的均值，是自相关系数，是自回归方程系数，是零均值，方差为的平稳白噪声
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `y` | array | 样本序列，为一维数组类型； |
| `p` | any | 自回归阶数； |
| `l` | any | 预测步长； |
返回：array
## `Time_AutoCov(y, l)`
声明：function
自协方差，求样本序列跟滞后L阶序列的协方差，即自协方差 自协方差计算公式如下： 其中：yt是样本序列，yL是滞后L阶的序列。
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `y` | array | 样本序列，为一维数组类型； |
| `l` | any | 滞后阶数，为整数类型； |
返回：any
## `Time_ChoseP(y, model, f)`
声明：function
判断AR模型最佳的阶数，采用信息准则函数判断模型的最佳阶数 其中：T为样本容量，K为待估计参数
| 参数 | 类型 | 说明 |
| ------- | ------ | -------------------------------------- |
| `y` | array | 样本序列，为一维数组类型； |
| `model` | string | 模型类别为AR、MA、ARMA，为字符串类型； |
| `f` | string | 判断准则为SBIC和AIC，为字符串类型 |
返回：any
## `Time_DanielTest(y, alpha)`
声明：function
在1-alpha置信水平下，进行随机时间序列的Daniel平稳性检验。返回结果为一个数组，第一个为q值(q>0：序列有上升趋势，q<0：序列有下降趋势)，第二个为T统计量，第三个为p值，第四个为是否接受原假设。原假设为x是平稳序列，所以H为1表示接受原假设，0表示拒绝原假设 其中：qs是Spearman相关系数，Rt为秩统计量，n为样本容量
| 参数 | 类型 | 说明 |
| ------- | ----- | ----------------------------------- |
| `y` | array | 随机时间序列，为一维数组类型 |
| `alpha` | float | 显著性水平，实数类型，取值在0-1之间 |
返回：array
## `Time_Diff(y, n)`
声明：function
序列差分
| 参数 | 类型 | 说明 |
| ---- | ----- | ----------------------- |
| `y` | array | 需要做差分的数组数据 |
| `n` | any | 差分的阶数，0阶不做处理 |
返回：any
## `Time_GARCH(rseries, model)`
声明：function
广义自回归条件异方差模型，包含四种模型：GARCH(1,1)、GJR(1,1)、IGARCH(1,1)和EGARCH(1,1)，本模型采用了最大似然估计法去估计模型的系数，可做一步预测。 GARCH(1,1)： GJR(1,1)： IGARCH(1,1)： EGARCH(1,1)： 最大似然估计的目标函数值为：
| 参数 | 类型 | 说明 |
| --------- | ------ | ---------------------------- |
| `rseries` | array | 资产收益率，为一维数组类型； |
| `model` | string | 模型类别，为字符串类型； |
返回：any
## `Time_GreenFun(ap, mq)`
声明：function
中间函数，ARMA模型的Green函数，Green函数的递推公式如下： 式中： ，，是自回归方程系数，为移动平均系数，
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `ap` | array | 自相关系数，为一维数组类型； |
| `mq` | array | 移动平均系数，为一维数组类型； |
返回：array
## `Time_InvFun(ap, mq)`
声明：function
中间函数，模型逆函数，ARMA模型的逆函数，Green函数的递推公式如下： 式中： ，，是自回归方程系数，为移动平均系数，
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `ap` | array | 自相关系数，为一维数组类型； |
| `mq` | array | 移动平均系数，为一维数组类型； |
返回：array
## `Time_MAq(y, q, l)`
声明：function
建议使用ARMA模型替换，移动平均模型，MA(q)模型，用条件最小二乘法去估计q阶移动平均模型的系数，返回结果有移动平均系数、残差方差、预测值及预测波动。 估计过程如下： MA(q)模型： 具有逆转形式： 用算子形式比较，可得： s 条件最小二乘法使得下列残差平方和最小： 可将上述转化为矩阵形式，先求得的取值，在利用上上式计算移动平均系数 如有常数，则常数项为原序列的均值。 ，为自协方差 其中：yt为原序列零均值化的新序列，μ为原序列的均值，θq为移动平均系数，εt是零均值，方差为σ2的平稳白噪声
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------------------- |
| `y` | array | 样本序列，为一维数组类型； |
| `q` | any | 移动平均阶数； |
| `l` | any | 预测步长； |
返回：array
## `Time_PACF(y)`
声明：function
偏自相关系数，计算随机序列与所有滞后阶数的偏自相关系数，返回结果是一个数组。偏相关系数的计算公式如下： 是自相关系数，是偏相关系数
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------ |
| `y` | array | 样本序列，为一维数组类型 |
返回：array
## `Time_RandomTest(y, m, alpha)`
声明：function
Ljung和Box提出的修正Qm统计量，用于检验序列是否为白噪声，原假设为白噪声序列，即纯随机序列。（Hypothesis为1表示接受原假设，0表示拒绝原假设） Qm统计量的计算公式如下： 其中：是自相关系数，T是样本容量，m是最大滞后长度
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------------- |
| `y` | array | 样本序列，为一维数组类型 |
| `m` | any | 最大滞后长度，整数类型，一般取样本数的四分之一 |
| `alpha` | float | 显著性水平，实数类型，取值在0-1之间 |
返回：array
## `Time_VolatilitySpillover(x, y, w_type, m, c_type)`
声明：function
波动溢出，底层模型为AR(3)-GARCH(1,1)，对时间序列X与Y进行Granger因果检验
| 参数 | 类型 | 说明 |
| -------- | ----- | ---------------------------------------------------------------------------------------------------- |
| `x` | array | 一维数字数组，时间序列X |
| `y` | array | 一维数字数组，时间序列Y |
| `w_type` | any | 整型 或 一维数字数组，加权方式，一维数字数组表示可同时返回多种加权方式 |
| `m` | any | 整数 或 一维数字数组，滞后阶数，一维数字数组表示同时计算多个M的场景，缺省时M:= array(5,10,20,30,40); |
| `c_type` | any | 整数，因果检验类型 |
返回：array
## `Times_ADFTest(y, diff, style, f, p, alpha)`
声明：function
时间序列的平稳性ADF检验；返回结果为ADF统计量和给定显著性水平下的ADF统计量的临界值；如果ADF统计量的绝对值比临界值的绝对值大，则可在该显著性水平下，拒绝原序列存在单位根的原假设，即原序列是平稳的
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------------------------------------------------------------------------- |
| `y` | array | 时间序列数据，为一维数组类型 |
| `diff` | any | 差分次数，整数类型，0表示不进行差分 |
| `style` | any | 是否存在常数或趋势项的选项，整数类型，无常数无趋势使用0、有常数无趋势1、有常数有趋势2 |
| `f` | string | 滞后阶数判断信息准则，字符串类型，"SBIC"，"AIC" |
| `p` | any | 滞后阶数，为整型类型，输入0则表示自动选择 |
| `alpha` | float | 显著性水平，实数类型，范围在0-1之间 |
返回：array
## `Times_Cointergration(y, x, alpha)`
声明：function
建议使用Times_Cointergration_test函数替换本函数，协整检验—E-G两步法检验变量的协整关系，E-G法如下： 1）在因变量与自变量存在同阶单整关系的条件，进行最小二乘法回归； 2）把回归后的残差进行平稳性检验，如果残差序列是平稳的，则两者存在协整关系，否则不存在。
| 参数 | 类型 | 说明 |
| ------- | ----- | ---------------------------------------------------------------- |
| `y` | array | 因变量，为一维数组类型； |
| `x` | array | 自变量矩阵，为二维数组类型； |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格； |
返回：string
## `Times_Cointergration_test(y, x, constant, alpha_type, style, criterion)`
声明：function
E-G两步法协整检验变量的协整关系，E-G法基本步骤如下： 1）在因变量与自变量存在同阶单整关系的条件，进行最小二乘法回归； 2）把回归后的残差进行平稳性检验，如果残差序列是平稳的，则两者存在协整关系，否则不存在。
| 参数 | 类型 | 说明 |
| ------------ | ------ | -------------------------------------------------------------------------------------------------- |
| `y` | array | 被解释变量，为一维数组类型 |
| `x` | array | 解释变量，为一维数组类型 |
| `constant` | bool | 回归方程是否含有常数项，为布尔类型 |
| `alpha_type` | float | 显著性水平，为实数类型，一般在0-1之间 |
| `style` | any | ADF法检验单整阶数时是否存在常数或趋势项，整数类型，无常数无趋势使用0、有常数无趋势1、有常数有趋势2 |
| `criterion` | string | 滞后阶数判断信息准则，字符串类型，"SBIC"，"AIC" |
返回：array
## `Times_ECM(y, x, resid, alpha, q, p)`
声明：function
两变量间的误差修正模型，准确的刻画了两序列间的短期波动特征 误差修正模型是时间序列间协整关系的主要表现形式，准确的刻画了序列间的长期均衡关系和短期波动特征。设一阶自回归分布滞后模型为： 其中，是均值为零，方差为的白噪声，进行适当的整理有： 其中若记 称为误差修正项。
| 参数 | 类型 | 说明 |
| ------- | ----- | -------------------------------------------- |
| `y` | array | 被解释变量，为一维数组类型 |
| `x` | array | 解释变量，为一维数组类型 |
| `resid` | array | 协整检验时的残差，没有输入，使用最小二乘得到 |
| `alpha` | float | 显著性水平 |
| `q` | any | 整数类型，被解释变量的滞后项 |
| `p` | any | 整数类型，解释变量的滞后项 |
返回：any
## `Times_Granger(y, x, q, alpha)`
声明：function
Granger因果检验，原假设：X不是Y的Granger原因，Hypothesis为1表示接受原假设，0表示拒绝原假设 原假设： 分别对上述两个回归方程做回归，提取残差平方和XESS跟YESS，则F统计量如下计算：
| 参数 | 类型 | 说明 |
| ------- | ----- | ------------------------------------- |
| `y` | array | 被解释变量，为一维数组类型 |
| `x` | array | 解释变量，为一维数组类型 |
| `q` | any | 滞后阶数，为整数类型 |
| `alpha` | float | 显著性水平，为实数类型，一般在0-1之间 |
返回：array
## `Times_GrangerCausality(series_matrix, lag_order)`
声明：function
对矩阵中的多个序列执行两两 Granger 因果检验。
| 参数 | 类型 | 说明 |
| --------------- | ----- | --------------------------------------------------- |
| `series_matrix` | array | 多个时间序列组成的矩阵；可由两条序列用 `left_series |
| `lag_order` | any | 滞后阶数 |
返回：array
## `Times_johansen(x, p, k)`
声明：function
进行Johansen协整检验，第一列的迹、最大特征值统计量的原假设是：没有协整关系；第二列的迹、最大特征值统计量的原假设是最多只有一个协整关系；第三列的迹、最大特征值统计量的原假设是最多只有两个协整关系……
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------------------------------------------------------------------------------------------------------------- |
| `x` | array | 输入多元时间序列,每一列为一指标，每行为一时间 (nobs\*m) |
| `p` | any | 是否含时间趋势及常数项p = -1,没有时间趋势以及常数项p =0,含常数项p =1,含常数项以及一次时间项p >1,含常数项以及高次时间项 |
| `k` | any | 滞后阶数 |
返回：array
## `toHttpPostdata(v, data_mode)`
声明：function
根据数据模式转换为字符串格式
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------------------------------ |
| `v` | any | 待转换的数据 |
| `data_mode` | string | 数据模式，支持 `json` 和 `tslstream` |
返回：string
### 示例
```tsl
value := array("Type": 1, "IDs": array("SZ000001"), "SUBs": array("date_s", "price"));
echo toHttpPostdata(value, "json");
// 输出：{"Type":1,"IDs":["SZ000001"],"SUBs":["date_s","price"]}
```
## `TSOptimizer`
声明：class
天软规划求解基类，以面向对象方式封装 `Prog_N`、`Prog_Q` 和 `Prog_L`。
来源：depth=3
Source ID：21162
Source URL：<http://www.tinysoft.com/tsdn/helpdoc/display.tsl?id=21162>
## `tssubplot_lines(data, fname_subplots, fname_date, fname_infos, dict_Indicator)`
声明：function
时序数据多子图折线图批量绘制函数，按分组配置自动生成多组折线子图，并自动处理时间格式化、数据列重命名和信息列合并。
| 参数 | 类型 | 说明 |
| ---------------- | ----- | -------------------------------- |
| `data` | array | 二维数组，原始时序数据集 |
| `fname_subplots` | array | 二维数组，子图分组配置 |
| `fname_date` | array | 时间字段名，用于生成标准化时间轴 |
| `fname_infos` | array | 一维字符串数组，附加信息列 |
| `dict_Indicator` | array | 一维数组，概览指标 |
返回：gsubplot
Source ID：37881
Source URL：<http://www.tinysoft.com/tsdn/helpdoc/display.tsl?id=37881>
## `uniffit(x, alpha)`
声明：function
根据样本x，x服从均匀分布，估计该分布的两个参数a,b
| 参数 | 类型 | 说明 |
| ------- | ------------- | ---------------------- |
| `x` | array of real | 均匀分布样本，数字数组 |
| `alpha` | real | 显著性水平，在0-1之间 |
返回：any
### 示例
```tsl
x := randunif(1, 10, 100);
return uniffit(x, 0.05);
// 输出：返回a, b的估计以及他们的在alpha的显著性水平下的区间估计
```
## `variationCoefficient(x)`
声明：function
变异系数。
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `x` | array | 一维数字数组 |
返回：real
### 示例
```tsl
return variationCoefficient(array(1, 2, 1, 2, 1, 2));
// 返回：0.33
```
## `wavedec(x, n, wname)`
声明：function
使用给定的小波wname进行一维多尺度离散小波分析，返回信号xin在n层上的小波分解。输出分解结构包含小波分解向量C和相应的记录向量L.
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------ |
| `x` | array | 一维序列，一维数字数组 |
| `n` | integer | 小波分解层数，正整数 |
| `wname` | string | 基础小波函数，字符串类型 |
返回：array
### 示例
```tsl
setSysParam(PN_Stock(), "SH000300");
setSysParam(pn_date(), intToDate(20120731));
close300 := nDay(800, "时间", dateTimeToStr(sp_time(1)), "收盘价", close());
close3 := close300[: , "收盘价"];
return wave := wavedec(close3, 3, "db3");
// 输出：结果格式：
// 第一行是小波分解向量C，第二行是相应的记录向量L
// 下面我们从图像来直接看看小波分解：
// 原始序列:
// 原始序列可分解成：
```
## `wavelet(s, wname, n, options)`
声明：function
一维序列小波消噪
| 参数 | 类型 | 说明 |
| --------- | ------- | ------------------------------------------------------------- |
| `s` | array | 一维序列，一维数字数组 |
| `wname` | string | 基础小波函数，字符串类型,取值参考[Wavedec]函数的wname输入参数 |
| `n` | integer | 小波分解层数，正整数 |
| `options` | array | 方法选项 |
返回：array
### 示例
```tsl
s := array(2484.83, 2479.05, 2482.34, 2437.79, 2447.75, 2512.96, 2443.06, 2433.16, 2393.18, 2415.05, 2392.06, 2365.34, 2359.22, 2344.79, 2348.52, 2420.00, 2438.79, 2431.38, 2440.4, 2383.49, 2377.51, 2331.37, 2317.27, 2370.33, 2409.67, 2427.48, 2435.61, 2473.41, 2468.25, 2470.02, 2504.11, 2508.09, 2528.29, 2509.8, 2503.84, 2524.92, 2479.54, 2481.08, 2528.71, 2529.76, 2466.96, 2463.05, 2416.56, 2415.13, 2412.62, 2395.06, 2397.55, 2380.22, 2383.03, 2412.39, 2333.41, 2386.86, 2360.66, 2333.23, 2325.91, 2332.73, 2329.82, 2315.27, 2291.54, 2248.59, 2228.52, 2180.9, 2224.84, 2218.24, 2215.93, 2191.15, 2186.3, 2204.78, 2190.11, 2166.21, 2170.01, 2173.56, 2199.42, 2169.39, 2148.45, 2163.4, 2225.89, 2285.74, 2276.05, 2275.01, 2244.58, 2206.19, 2298.38, 2266.38, 2296.07, 2319.12, 2285.04, 2292.61, 2268.08, 2312.56, 2330.41, 2331.14, 2291.9, 2347.53, 2349.59, 2351.98, 2351.85, 2344.77, 2366.7, 2356.86, 2357.18, 2363.6, 2381.43, 2403.59, 2409.55, 2439.63, 2447.06, 2451.86, 2428.49, 2426.11, 2460.69);
n := 2;
wname := "db14";
options := array('brief': 1, 'sigma': 0, 'which': 1, 'alpha': 2, "thr": 0, 'sorh': 's');
return s|wavelet(s, wname, n, options);
// 消噪和原始数据对比：
```
## `wrcoef(o, c, l, wname, n)`
声明：function
一维离散小波单支重构，小波分析，小波重构中间函数或者细节系数（高频）提取
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------------------------------- |
| `o` | string | 为字符串类型，'a' 一维离散小波单支重构，'d' 细节系数提取 |
| `c` | array | 小波分解向量C，数组类型，参考[Wavedec]函数的输出 |
| `l` | array | 相应的记录向量L，数组类型，参考[Wavedec]函数的输出 |
| `wname` | string | 基础小波函数，字符串类型,取值参考[Wavedec]函数的wname输入参数 |
| `n` | integer | 小波分解层数，正整数 |
返回：array
### 示例
```tsl
setSysParam(PN_Stock(), "SH000300");
setSysParam(pn_date(), intToDate(20120731));
close300 := nDay(800, "时间", dateTimeToStr(sp_time(1)), "收盘价", close());
close3 := close300[: , "收盘价"];
wave := wavedec(close3, 3, "db3");
c := wave[0];
l := wave[1];
return wrcoef('a', c, l, 'db3', 3); // 去除前3层高频谐波
// Return wrcoef('d',c,l,'db3',3);//第3次分解得到的高频
// 输出：
// 去除前3层高频谐波
return wrcoef('d', c, l, wname, 3); // 第三次分解得到的高频
```
## `writeToLog(dir, sub_dir, value)`
声明：function
向虚拟目录写日志。其中Dir为虚拟目录名，SubDir为文件名，成功写入日志后，会生成命名为’SubDir’+写入日期+’.log’的TXT文件，文件内容为写入时间->Value。用户使用其应当申请好服务器权限。 20250512升级：优化多个线程同时写入时存在丢失情况： 1、增加重试次数，重试20次间隔0.5秒。 2、增加返回内容。 注意：在极端情况下（超多多线程下同时写入）可能还会存在写入失败情况，此时可通过返回结果继续处理
| 参数 | 类型 | 说明 |
| --------- | ------ | -------------------------------------------------------------------------------------------------------------------------------- |
| `dir` | string | 字符串，虚拟目录别名，一般在安装目录\Tinysoft\Analyse.NET\Plugin\filemgr.ini中进行配置。如果没有配置别名，该参数赋值为空字符""。 |
| `sub_dir` | string | 字符串，文件名 |
| `value` | string | 字符串，需要写入日志的内容 |
返回：any
## `ytmToAccumulativeYtm(t, f_name, dw)`
声明：function
日收益率转换复合收益率。
| 参数 | 类型 | 说明 |
| -------- | ------- | ---------------------------------- |
| `t` | array | 数组。日收益率序列 |
| `f_name` | string | 字符串。收益字段名称 |
| `dw` | integer | 整数。决定源数据的单位和返回的数据 |
返回：array|real
### 示例
范例01：
```tsl
// 源数据单位为1,dw=2,同时返回日收益率和转换后的复合收益率
t1 := array(('日期': 20180801T, '日收益率': 0.3),
('日期': 20180802T, '日收益率': 0.6),
('日期': 20180803T, '日收益率': 0.9));
r1 := ytmToAccumulativeYtm(t1, '日收益率', 2, 0);
// 源数据单位为%,dw=3,同时返回日收益率和转换后的复合收益率
t2 := array(('日期': 20180801T, '日收益率(%)': 30),
('日期': 20180802T, '日收益率(%)': 60),
('日期': 20180803T, '日收益率(%)': 90));
r2 := ytmToAccumulativeYtm(t2, '日收益率(%)', 3, 0);
return r1|r2;
```
范例2：
```tsl
// 计算基金OF000009易方达天天理财A的累计收益率(%)
setSysParam(PN_Stock(), "OF000009");
t := array(('日期': 20150104T, '每万份基金单位收益': 4.3769),
('日期': 20150105T, '每万份基金单位收益': 1.2507),
('日期': 20150106T, '每万份基金单位收益': 1.4671));
r := ytmToAccumulativeYtm(t, '每万份基金单位收益', 5, 0);
return r;
```
## `abnormalData(y, flag, ystore)`
声明：function
数组中出现奇异值的处理。其中y为数据表，Flag为处理方法，Ystore为选择中位数和3倍标准差法返回被处理数据的数据。
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------------ |
| `y` | array | 一维数字数组 |
| `flag` | string | 用户自定义，奇异值处理方法 |
| `ystore` | array | 数据表类型，存放修改的数据，包括修改的行、原数值、处理后的值 |
返回：any
### 示例
示例：返回奇异值的位置及处理后的结果。
```tsl
t := array(1, 100, 101, 102, 103, 1000);
abnormalData(t, "median", r);
return r;
// 返回:
// 其中，0和5为修改的行，1和1000是对应的原值，93.7和109.3是修改后的值
```
## `appendArray(arr, con)`
声明：function
数组新增元素，给数组arr添加一项con
| 参数 | 类型 | 说明 |
| ----- | ------- | ------------------------ |
| `arr` | array | 一维数组 |
| `con` | integer | 整数或字符串，需增加的值 |
返回：array
### 示例
```tsl
a := array(1, 2, 3);
appendArray(a, 4);
return a;
// 返回:
```
## `argconfirst(a, v, _type)`
声明：function
第一次满足条件的位置, 原数组必须为有序表且元素应可比较。
| 参数 | 类型 | 说明 |
| ------- | ------------------- | -------- |
| `a` | array | 有序数组 |
| `v` | string\|real\|array | 对比值 |
| `_type` | integer | 对比条件 |
返回：integer
### 示例
范例1：实数对比
```tsl
a := 0->9;
return argconfirst(a, 3.5, 1); // 返回：4
```
范例2：数组对比
```tsl
a := array(("a", "A"), ("b", "B"), ("c", "C"), ("d", "D"));
v := array("b", "B");
return argconfirst(a, v, 6); // 返回：1
```
## `argmax(x)`
声明：function
1、返回一维数组中最大值所在下标
<!-- tags: 数组 列表 array list 最大值 最大 maximum max 下标 索引 位置 index position -->
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ------------ |
| `x` | array,tablearray | 一维数字数组 |
返回：integer
### 示例
```tsl
x := array(9, 8, 10);
return argmax(x);
// 输出：2
```
## `argmin(x)`
声明：function
1、返回一维数组中最小值所在下标
| 参数 | 类型 | 说明 |
| ---- | ---------------- | ------------ |
| `x` | array,tablearray | 一维数字数组 |
返回：integer
### 示例
```tsl
x := array(3, 1, 9, 2);
return argmin(x); // 1
```
## `argsort(value, sortdir)`
声明：function
返回可以用于排序的一维数组下标
| 参数 | 类型 | 说明 |
| --------- | ------- | --------------------------------------- |
| `value` | array | 一维数字数组，数组 |
| `sortdir` | integer | 整数，排序方向（1:正序【默认】;0:逆序） |
返回：array
### 示例
```tsl
value := array(4, 8, 2, 3, 9);
return argsort(value); // 返回：array(2,3,0,1,4)
```
## `arrayAddGap(t, key, v, m)`
声明：function
数组添加分割线,只支持字符串下标
| 参数 | 类型 | 说明 |
| ----- | ------- | ------------------------------------------- |
| `t` | array | 数组，待添加数组，直接在原数组更改 |
| `key` | string | 字符串，间隔名，默认无 |
| `v` | string | 字符串，间隔串，默认为 DupeString('-',m\*2) |
| `m` | integer | 整型，间隔串的长度设置，默认 5 |
返回：array
### 示例
```tsl
a := array('alpha(%)': 3);
arrayAddGap(a, '风险');
a['beta'] := 3;
return a; // array("alpha(%)":3,"-----风险-----":"----------","beta":3)
```
## `arrayextend(a, ind, v)`
声明：function
数组-指定位置插入子集
| 参数 | 类型 | 说明 |
| ----- | --------------- | ---------------------------- |
| `a` | array of number | Array of number,一维数字数组 |
| `ind` | integer | Integer,插入的起始位置 |
| `v` | array of number | Array of number,插入的子数组 |
返回：array
### 示例
```tsl
a := letters(1->6);
return arrayextend(a, 2, array('d', 'e'));
// 返回：array("A", "B", "d", "e", "C", "D", "E", "F")
```
## `arraygetdefault(r, k, v)`
声明：function
带默认值的数组取值，取指定下标的值，若存在则返回，否则返回设定的默认值
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `r` | array of string | Array of string, |
| `k` | string | String,下标 |
| `v` | string | String,默认值 |
返回：any
### 示例
```tsl
r := array("a": 1, "b": 2);
return arraygetdefault(r, "x", 99); // 下标 x 不存在，返回默认值 99；若取 "a" 则返回 1
// 输出：99
```
## `arrayinsert(a, ind, v)`
声明：function
数组-指定位置插入值
| 参数 | 类型 | 说明 |
| ----- | --------------- | ---------------------------- |
| `a` | array of number | Array of number,一维数字数组 |
| `ind` | integer | Integer,插入位置 |
| `v` | any | Any,元素值 |
返回：array
### 示例
```tsl
a := letters(1->6);
return arrayinsert(a, 2, 3);
// 返回：array("A", "B", 3, "C", "D", "E", "F")
```
## `arraysetdefault(r, k, v)`
声明：function
带默认值的数组赋值(字段未使用则赋值)
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `r` | array of string | Array of string, |
| `k` | string | String,下标 |
| `v` | string | String,默认值 |
返回：bool
### 示例
```tsl
r := array("a": 1, "b": 2);
arraysetdefault(r, "x", 99); // 下标 x 未使用，赋值 99 并返回 true；若对已存在的 "a" 调用则不改、返回 false
return r;
// 输出：array("a":1,"b":2,"x":99)
```
## `arraysetdefault2(r, k, v)`
声明：function
带默认值的数组赋值(值为nil则赋值)
| 参数 | 类型 | 说明 |
| ---- | --------------- | ---------------- |
| `r` | array of string | Array of string, |
| `k` | string | String,下标 |
| `v` | string | String,默认值 |
返回：bool
### 示例
```tsl
r := array("a": 1, "b": nil);
arraysetdefault2(r, "b", 99); // b 的值为 nil，赋值 99 并返回 true；下标缺失时同样赋值
return r;
// 输出：array("a":1,"b":99)
```
## `aveDevByColumn(t, f_name)`
声明：function
指定列与平均值的绝对偏差的平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return aveDevByColumn(t2, 'c');
// 结果：12.5
```
## `averageByColumn(t, f_name)`
声明：function
求指定列的平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return averageByColumn(t1, 'b');
// 结果：6
```
## `averageValueByColumn(t, f_name, from_row, to_row)`
声明：function
求在指定多行中指定列的平均值
| 参数 | 类型 | 说明 |
| ---------- | ------- | --------------------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
| `from_row` | integer | 计算起始行索引号（从0开始） |
| `to_row` | integer | 计算结束行索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return averageValueByColumn(t2, 'c', 1, 3);
// 结果：43
```
## `boolToStr(b, use_bool_strs)`
声明：function
将布尔型转换成字符串类型并返回。参数UseBoolStrs一般为假，如果B为真，函数返回'-1',如果B为假，返回'0'。若想返回’True’与’False’的结果可用BoolToStr2实现。
| 参数 | 类型 | 说明 |
| --------------- | ---- | -------------------- |
| `b` | bool | 要转换的布尔值 |
| `use_bool_strs` | bool | 布尔型，一般传入假值 |
返回：string
## `call(func_name, p1, pn)`
声明：function
根据名称或者函数指针调用指定的函数，后面带的参数将自动送入该函数。
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------- |
| `func_name` | string | TFunction |
| `p1` | any | 整数，参数1 |
| `pn` | any | 整数，参数N。 |
返回：any
## `callInArray(func, args)`
声明：function
以参数数组调用指定函数（含函数名或函数变量）。
| 参数 | 类型 | 说明 |
| ------ | ------ | ---------------------- |
| `func` | string | 函数名字符串或函数指针 |
| `args` | array | 参数数组 |
返回：any
## `columnValue(t, fname)`
声明：function
取得指定列的所有值(按列名)。该函数的功能与直接用读取子矩阵的方式一样，但是用子矩阵的方式更简单快速。功能相当于t[:,fname]
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `fname` | string | 字符串，列字段名称 |
返回：any
### 示例
```tsl
s := select ['StockID'] as '代码',
["StockName"] as "名称",
['price'] as '收盘'
from markettable datekey 20190101T to 20190201T of 'SZ000001' end;
return columnValue(s, '收盘');
// 返回:
```
## `columnValue2(t, column_name)`
声明：function
取得多个指定列的所有记录
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------------ |
| `t` | array | 数据表，二维数组 |
| `column_name` | string | 指定多个字段，以分号分割 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'b': 2, 'c': 13), ('a': 3, 'c': 33, 'b': 3), ('a': 3, 'b': 6, 'c': 43), ('a': 5, 'c': 53, 'b': 5));
return columnValue2(t2, 'a;c');
```
## `compareDataOfDifferentDataProvider(t_src, t_dest, src_provider, dest_provider, key_arr, value_arr, code_field)`
声明：function
比较两个数据源的差异
| 参数 | 类型 | 说明 |
| --------------- | ------ | ------------------------------------------------------ |
| `t_src` | array | Array 源数据 |
| `t_dest` | array | Array 目标数据 |
| `src_provider` | string | String 源数据提供商 |
| `dest_provider` | string | String 目标数据提供商 |
| `key_arr` | array | Array 要比较表的Key字段（也就是数据表中的 唯一性字段） |
| `value_arr` | array | Array 要比较的Value字段 |
| `code_field` | string | String 代码字段（任何数据，都必须有编码字段） |
返回：array
### 示例
```tsl
src := array(("code": "A", "value": 1));
dest := array(("code": "A", "value": 1));
result := compareDataOfDifferentDataProvider(
src,
dest,
"source",
"target",
array("code"),
array("value"),
"code"
);
echo trim(toStn(result));
```
## `dataisequal(v1, v2)`
声明：function
判断2个变量是否相等
| 参数 | 类型 | 说明 |
| ---- | ---- | -------------- |
| `v1` | any | 任意类型,变量1 |
| `v2` | any | 任意类型,变量2 |
返回：bool
### 示例
```tsl
echo dataisequal(array("code": "A"), array("code": "A"));
```
## `DataProcess_MF(arr, fwm)`
声明：function
极值处理(多因子),对数据表以列为单位处理奇异值。其中arr为数据表，fwm为处理方法。
| 参数 | 类型 | 说明 |
| ----- | ------ | -------------------- |
| `arr` | array | 数据表类型 |
| `fwm` | string | 用户自定义，处理方法 |
返回：any
### 示例
```tsl
data := array(array(1, 100, 101, 102, 103, 1000), array(2, 200, 201, 202, 203, 2000));
echo trim(toStn(DataProcess_MF(data, "median")));
```
## `dateStrToArr(end_dates, sep1, sep2)`
声明：function
把日期区间字符串转换为列表
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------- |
| `end_dates` | string | 日期区间字符串 |
| `sep1` | string | 日期区间字符串分割符 |
| `sep2` | string | 开始和截止日期分割符 |
返回：array
### 示例
```tsl
return dateStrToArr('2007-9-10;2007-9-10', '$', ';'); // '$'表示结束位置
```
## `dateTimeToString(format, date_time)`
声明：function
根据参数Format给定的格式串将参数DateTime转换成字符串类型存到参数Result中，其中格式串的使用参照FormaTDateTime函数
| 参数 | 类型 | 说明 |
| ----------- | -------- | ------------------------------- |
| `format` | any | 字符串，格式串 |
| `date_time` | datetime | TDateTime类型，需转换的日期时间 |
返回：string
## `dbglocalcancel(id, return_value)`
声明：function
注销任务。该功能可以用来终止运行的WEB任务。 其任务ID为dbglocalrunning中返回信息中的id字段以十六进制模式转换为64位整数。
| 参数 | 类型 | 说明 |
| -------------- | ---- | ----------------------------------------------------------------- |
| `id` | int | 为dbglocalrunning中返回信息中的id字段以十六进制模式转换为64位整数 |
| `return_value` | bool | object |
返回：bool
## `decToInt(s)`
声明：function
将字符串转换为整数。
| 参数 | 类型 | 说明 |
| ---- | ------ | ---------------------- |
| `s` | string | 字符串。需转换的字符串 |
返回：integer
### 示例
范例01
```tsl
return decToInt("12"); // 输出: 12
```
范例02：十六进制格式字符串的转换
```tsl
return decToInt("0x12"); // 报错
return strToInt("0x12"); // 输出：18
```
## `decToInt32(s)`
声明：function
将字符串转换为32位整数。
| 参数 | 类型 | 说明 |
| ---- | ------ | ---------------------- |
| `s` | string | 字符串。需转换的字符串 |
返回：integer
### 示例
范例01
```tsl
return decToInt32("12"); // 输出: 12
```
范例02：十六进制格式字符串的转换
```tsl
return decToInt32("0x12"); // 报错
return strToInt32("0x12"); // 输出：18
```
## `decToInt32Def(s, default)`
声明：function
将字符串转换为32位整数。如果转换失败，则返回Default值。
| 参数 | 类型 | 说明 |
| --------- | ------- | ---------------------------- |
| `s` | string | 字符串。需转换的字符串 |
| `default` | integer | 整数。转换失败时返回的默认值 |
返回：integer
### 示例
范例01
```tsl
return decToInt32Def("12", 1); // 输出: 12
return decToInt32Def("test", 1); // 输出: 1
```
范例02：十六进制格式字符串的转换
```tsl
return decToInt32Def("0x12", 1); // 输出: 1
return strToInt32Def("0x12", 1); // 输出：18
```
## `decToInt64(s)`
声明：function
将字符串转换为64位整数。
| 参数 | 类型 | 说明 |
| ---- | ------ | ------------------------ |
| `s` | string | 字符串。需转换的字符串。 |
返回：integer
### 示例
范例01：
```tsl
return decToInt64("12"); // 输出: 12L
```
范例02：十六进制格式字符串的转换
```tsl
return decToInt64("0x12"); // 报错
return strToInt64("0x12"); // 输出：18L
```
## `decToInt64Def(s, default)`
声明：function
将字符串转换为64位整数。如果转换失败，则返回Default值。
| 参数 | 类型 | 说明 |
| --------- | ------- | ---------------------------- |
| `s` | string | 字符串。需转换的字符串 |
| `default` | integer | 整数。转换失败时返回的默认值 |
返回：integer
### 示例
范例01
```tsl
return decToInt64Def("12", 1); // 输出: 12L
return decToInt64Def("test", 1); // 输出: 1L
```
范例02：十六进制格式字符串的转换
```tsl
return decToInt64Def("0x12", 1); // 输出: 1L
return strToInt64Def("0x12", 1); // 输出：18L
```
## `decToIntDef(s, default)`
声明：function
将字符串转换为整数。如果转换失败，则返回Default值。
| 参数 | 类型 | 说明 |
| --------- | ------- | ---------------------------- |
| `s` | string | 字符串。需转换的字符串 |
| `default` | integer | 整数。转换失败时返回的默认值 |
返回：integer
### 示例
范例01
```tsl
return decToIntDef("12", 1); // 输出: 12
return decToIntDef("test", 1); // 输出: 1
```
范例02：十六进制格式字符串的转换
```tsl
return decToIntDef("0x12", 1); // 输出: 1
return strToIntDef("0x12", 1); // 输出：18
```
## `deleteColumnByField(t, fields)`
声明：function
删除指定列，可以一次性删除多列，删除的列字段之间使用；分割
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------------------------ |
| `t` | array | 指定数组，数据表列名为字符串类型，程序执行完后会变更为删除指定列后的数组 |
| `fields` | string | 指定列，字符串 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return deleteColumnByField(t1, 'a;b');
```
## `deleteNilValueByField(t, fields)`
声明：function
删除指定字段fields数据为NIL的记录。
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------- |
| `t` | array | 数据表类型，数据 |
| `fields` | string | 字符串，字段名称，多个字段用分号（;）连接，例:＂Field1;Field2＂ |
返回：array
### 示例
```tsl
tdata := array(array('time': 1, 'price': 7.78), array('time': 2));
deleteNilValueByField(tdata, 'price');
return tdata;
// 返回:
// array(
// ("time":1,"price":7.78))
```
## `descartesJoin(v1, v2, v_n)`
声明：function
数组笛卡尔积连接。
| 参数 | 类型 | 说明 |
| ----- | ---- | --------------------------------- |
| `v1` | | 任意类型，支持不定个数参数，数值1 |
| `v2` | | 任意类型，数值2 |
| `v_n` | | 任意类型，数值3 |
返回：array,tablearray
### 示例
```tsl
return descartesJoin(1->3, 21->22, 3);
// 输出：
// array(
// (1,21,3),
// (1,22,3),
// (2,21,3),
// (2,22,3),
// (3,21,3),
// (3,22,3))
```
## `describe(data, percentiles)`
声明：function
简单描述统计
| 参数 | 类型 | 说明 |
| ------------- | --------------- | ---------------------------------------------------- |
| `data` | array of number | 一维数字数组,或 二维矩阵。二维矩阵时，对每列进行操作 |
| `percentiles` | array of number | 统计的分位点，默认取array(0.25,0.5, 0.75) |
返回：array
### 示例
范例01:
```tsl
load_dataset_iris(data);
return describe(data);
```
范例02:
```tsl
return describe(randn(0, 1, 1000), array(0.05, 0.1)->0.95);
```
## `devsqByColumn(t, f_name)`
声明：function
指定列平均值偏差的平方和
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return devsqByColumn(t1, 'b');
// 结果：0.5
```
## `distinctStr(t)`
声明：function
去掉序列中的重复元素
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------- |
| `t` | array | 一维字符串/数字数组 |
返回：array
### 示例
```tsl
a := array('w', 'd', 'f', 'd', 'e');
return distinctStr(a); // 保留不相同的，相同的只保留一个
```
## `divMod(dividend, divisor, remainder)`
声明：function
计算整数除法的整数商和余数。也就是用参数Dividend除以参数Divisor，得到的整数商存到参数Result中，把余数存到参数Remainder中
| 参数 | 类型 | 说明 |
| ----------- | ---- | ------------ |
| `dividend` | int | 整数，被除数 |
| `divisor` | int | 整数，除数 |
| `remainder` | int | 整数，余数 |
返回：float
## `divValue(v1, v2)`
声明：function
除法运算。
| 参数 | 类型 | 说明 |
| ---- | ---- | ------------ |
| `v1` | real | 实数，被除数 |
| `v2` | real | 实数，除数 |
返回：real
### 示例
```tsl
return divValue(8, 2);
// 返回：4
```
## `dumies_decode(dumiesdata)`
声明：function
虚拟变量矩阵解构，根据所给的虚拟变量矩阵返回分类变量结果
| 参数 | 类型 | 说明 |
| ------------ | ----- | -------------------------- |
| `dumiesdata` | array | 二维数字数组，虚拟变量矩阵 |
返回：array
### 示例
```tsl
data := array(
("real_estate": 1, "metal": 0, "bank": 0),
("real_estate": 0, "metal": 1, "bank": 0),
("real_estate": 0, "metal": 0, "bank": 1)
);
echo trim(toStn(dumies_decode(data)));
```
## `elementWhere(con, x, y)`
声明：function
根据布尔数组con,为True时从X中，为False时从Y中，取对应位置元素的值
| 参数 | 类型 | 说明 |
| ----- | ---------------- | ---- |
| `con` | array,tablearray | |
| `x` | array,tablearray | |
| `y` | array,tablearray | |
返回：array,tablearray
### 示例
```tsl
con := array(1, 0, 1, 1, 1, 0);
x := array(1, 2, 3, 4, 5, 6);
y := array(11, 12, 13, 14, 15, 16);
return elementWhere(con, x, y); // array(1,12,3,4,5,16)
```
## `endOfTheHalfYear(end_t)`
声明：function
返回Endt所在半年的截止日期（半年的最后一天）
| 参数 | 类型 | 说明 |
| ------- | --------- | ---- |
| `end_t` | tdatetime | 日期 |
返回：tdatetime
### 示例
```tsl
end_t := 40540; // 40540表示2010年12月28日
return endOfTheHalfYear (end_t);
// 结果：40543 //40543表示2010年12月31号
```
## `endOfTheQuarter(end_t)`
声明：function
返回Endt所在季度的截止日期（季度的最后一天）
| 参数 | 类型 | 说明 |
| ------- | --------- | ---- |
| `end_t` | tdatetime | 日期 |
返回：tdatetime
### 示例
```tsl
end_t := 40540; // 40540表示2010年12月28日
return endOfTheQuarter (end_t);
// 结果：40543 //40543表示2010年12月31号
```
## `ensureRange(a_value, amin, amax)`
声明：function
这个函数可以保证返回某个区间之内的数，参数Amin和参数Amax是这个区间的上限和下限。 如果参数Avalue大于等于参数Amin并且小于等于参数Amax，则返回Avalue 如果参数Avalue大于参数Amax，则返回Amax的值 如果参数Avalue小于参数Amin，则返回Amin的值
| 参数 | 类型 | 说明 |
| --------- | ----- | ---------------- |
| `a_value` | float | 要限制范围的实数 |
| `amin` | float | 实数，范围下限 |
| `amax` | float | 实数，范围上限 |
返回：float
## `excelDateToInt(r_date)`
声明：function
将日期型报告期转化成整数型报告期
| 参数 | 类型 | 说明 |
| -------- | --------- | ------------ |
| `r_date` | tdatetime | 日期型报告期 |
返回：integer
### 示例
```tsl
r_date := 20101231;
return excelDateToInt(r_date);
// 结果：20101231
```
## `excelIntToDate(r_date)`
声明：function
将报告期类型日期转化成实数型
| 参数 | 类型 | 说明 |
| -------- | ------- | ------------------ |
| `r_date` | integer | 整型类的报告期日期 |
返回：tdatetime
### 示例
```tsl
// 报告期为2010年年报
r_date := 20101231;
return excelIntToDate(r_date);
// 结果：40543
```
## `excelRDate(r_date)`
声明：function
将整数报告期转换成Excel的字符串日期类型
| 参数 | 类型 | 说明 |
| -------- | ------- | -------------------------- |
| `r_date` | integer | 报告期，一般用整型日期表示 |
返回：string
### 示例
```tsl
r_date := 20101231;
return excelRDate(r_date);
// 结果：2010-12-31
```
## `expandTable(t, key_field)`
声明：function
按指定字段展开表格，根据Keyfield展开指定列。展开的列值必须二维数据表，否则保留原值。
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------------------- |
| `t` | array | 数组类型，数据 |
| `key_field` | string | 字符串类型，关键字，需展开的列名 |
返回：array
### 示例
```tsl
// 按照分红送股列展开数据：分红送股列本身是子表，展开为多行
data := array(
("代码":"SH600000","名称":"浦发银行","分红送股":array(("年度":2019,"派息":6),("年度":2020,"派息":8))),
("代码":"SZ000002","名称":"万科A","分红送股":array(("年度":2020,"派息":12))));
return expandTable(data, "分红送股");
// 输出：
// array(
// ("代码":"SH600000","名称":"浦发银行","分红送股":2019),
// ("分红送股":6),
// ("分红送股":2020),
// ("分红送股":8),
// ("代码":"SZ000002","名称":"万科A","分红送股":2020),
// ("分红送股":12))
```
## `exportFile(filename, arg2, arg3, data)`
声明：function
文件访问函数相关函数。
| 参数 | 类型 | 说明 |
| ---------- | ------ | ---- |
| `filename` | int | |
| `arg2` | string | |
| `arg3` | string | |
| `data` | array | |
返回：string
## `exportJsonStringMbcs(data, n, return_value)`
声明：function
将TSL结构数据转换为json串。和ExportJSONString不同的是，该函数不会对中文进行转码处理，保留中文原码。
| 参数 | 类型 | 说明 |
| -------------- | ------- | ------------------------------------------------------------------------- |
| `data` | AnyType | 天软数据，任意数据类型。 |
| `n` | int | 可选。要保留的小数位数。为0时保留1位小数，大于16或小于0时保留全部小数位数 |
| `return_value` | string | 字符串，json串 |
返回：string
## `exportJsonStringUtf8(data, n, return_value)`
声明：function
将天软数组转换为UTF8编码的Json串，解决与第三方交互时的转码问题。
| 参数 | 类型 | 说明 |
| -------------- | ------- | ------------------------------------------------------------------------- |
| `data` | anytype | 天软数据，任意数据类型。 |
| `n` | int | 可选。要保留的小数位数。为0时保留1位小数，大于16或小于0时保留全部小数位数 |
| `return_value` | string | 字符串，UTF8编码的Json字符串。 |
返回：string
## `factorize(value, ifsort, nan_fill_value, uniques)`
声明：function
分类变量数值映射，将一个一维分类变量数组映射为给分类变量递增编号后的数值数组
| 参数 | 类型 | 说明 |
| ---------------- | ----- | ---------------------------------- |
| `value` | array | 数组，一维数组 |
| `ifsort` | bool | 布尔型，是否排序，默认不排序 |
| `nan_fill_value` | any | 数字/字符串，填充nan的值，默认为-1 |
| `uniques` | array | 数组，输出，各值对应的原值 |
返回：array
### 示例
```tsl
value := Array('a', 'd', 'c', 'a', 'b');
labels := factorize(value, true, -1, uniques);
echo uniques; // array("a","b","c","d")
return labels; // array(0,3,2,0,1);
```
## `Field_AddPrefix(t, prefix, ifcopy)`
声明：function
数组下标批量加前缀。
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------------- |
| `t` | array | 数组类型，数据 |
| `prefix` | string | 字符串类型，前缀 |
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddPrefix(data, "pre_", true)));
```
## `Field_AddSuffix(t, suffix, ifcopy)`
声明：function
数组下标批量加后缀。
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------------- |
| `t` | array | 数组类型，数据 |
| `suffix` | string | 字符串类型，后缀 |
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Field_AddSuffix(data, "_new", true)));
```
## `Field_ReSortCols(data, cols_showpriority)`
声明：function
数组下标按指定顺序重排 ps：不检查字段是否存在
| 参数 | 类型 | 说明 |
| ------------------- | ----- | --------------------------------- |
| `data` | array | 二维数字数组,数组，目前只支持二维 |
| `cols_showpriority` | array | 一维字符串数组,字段显示优先级 |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1, "date": 20250101));
priority := array("value": 100, "date": -1);
echo trim(toStn(Field_ReSortCols(data, priority)));
```
## `fieldCount(t)`
声明：function
数据表字段个数。如果t不是一个数据表，则返回0
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldCount(t1);
// 结果：2
```
## `fieldCountOfStrSubscript(t)`
声明：function
字符串下标数组的字段个数。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `t` | array | 数据表类型 |
返回：integer
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return fieldCountOfStrSubscript(s);
// 返回：4
```
## `fieldExist(t, f_name)`
声明：function
指定字段是否存在。如果存在，则返回索引号；(索引号从0开始)，不存在，返回－1
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定字段，字符串 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldExist(t1, 'b');
// 结果：1
```
## `fieldName(t, field_index)`
声明：function
返回数据表指定列索引号（索引号从0开始）的字段名称
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------ |
| `t` | array | 数据表 |
| `field_index` | integer | 指定列，整数 |
返回：string
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return fieldName(t1, 0);
// 结果：’a’
```
## `fieldNames(t)`
声明：function
返回数据表所有字段名称
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));return fieldNames(t1);
```
## `fieldNamesOfStrSubscript(t)`
声明：function
字符串下标数组的字段名称。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `t` | array | 整数 |
返回：any
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (2, 3, 4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return fieldNamesOfStrSubscript(s);
// 返回:
```
## `fileDateToDateTime(filename)`
声明：function
日期时间处理函数。
| 参数 | 类型 | 说明 |
| ---------- | ---- | ---- |
| `filename` | int | |
返回：datetime
## `filterIntersectionPart(t1, t2, f_name, method)`
声明：function
求两个数组在指定列名上的差集、交集、并集
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------------------------------------------- |
| `t1` | array | 数据表 |
| `t2` | array | 数据表 |
| `f_name` | string | 指定列名字符串 |
| `method` | string | 方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 10, 'c': 13), ('a': 2, 'b': 17, 'c': 13));
t2 := array(('a': 2, 'b': 22, 'c': 23), ('a': 1, 'b': 14, 'c': 13), ('a': 3, 'b': 12, 'c': 13));
return filterIntersectionPart(t1, t2, 'a', 'IN'); // t1 与 t2 在列 a 上的交集
// 输出：返回 t1 中 a 值出现在 t2 中的行
// array(
// ("a":1,"b":10,"c":13),
// ("a":2,"b":17,"c":13))
// method='NOT IN' 时返回 t1 中 a 值不在 t2 的行(此例为空 array())；
// method='ALL' 时返回并集(此例为 t2 的三行，a=2,1,3)。
```
## `filterIntersectionPart2(t1, t2, method)`
声明：function
求两个数组的差集、交集、并集。只适用一维数组。
| 参数 | 类型 | 说明 |
| -------- | ------ | ----------------------------------------------- |
| `t1` | array | 一维数据表 |
| `t2` | array | 一维数据表 |
| `method` | string | 方法，’IN’交集，’NOT IN’差集，’ALL’并集，字符串 |
返回：array
### 示例
```tsl
t1 := array(1, 2, 3, 4);
t2 := array(3, 4, 5, 6);
return filterIntersectionPart2(t1, t2, 'IN'); // t1 与 t2 的交集
// 输出：array(3,4)
// method='NOT IN' 返回 t1 中不在 t2 的元素 array(1,2)；
// method='ALL' 返回并集 array(3,4,5,6,1,2)。
```
## `filterOneDimEx(t, method, v1, v2)`
声明：function
范围取值（一维数组）从一个一维数组中按照取值范围返回对应的记录。
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------------------------- |
| `t` | array | 数据表 |
| `method` | string | ’>’，’<’，’<>’，’<=’，’>=’，’IN’，’IN2’，’IN3’ |
| `v1` | real | 实数 |
| `v2` | real | 实数 |
返回：array
### 示例
```tsl
t := array(1, 2, 12, 3.7, 14);
return filterOneDimEx(t, 'IN', 2, 7);
```
## `filterOneDimEx2(t, v1)`
声明：function
小于等于指定值的最后一条记录(一维数组)。
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------ |
| `t` | array | 一维数字数组 |
| `v1` | real | 实数，指定值 |
返回：real
### 示例
```tsl
s := array(1, 2, 3, 4, 5, 6);
return filterOneDimEx2(s, 4);
// 返回：4
```
## `filterTable(t, v)`
声明：function
从指标表中取以下列的值为v的数据：
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------ |
| `t` | array | 数组类型，数据 |
| `v` | integer | 报告期类型，报告期 |
返回：array
### 示例
```tsl
// 'SZ002664'在20211231时的分红送股数据
setSysParam(pn_stock(), 'SZ002664');
return filterTable(infoArray(18), 20211231);
```
## `filterTableEx(t, fname, method, v1, v2)`
声明：function
范围取值，从一个表中按照某个字段的取值范围返回对应的记录
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------------------------------------- |
| `t` | array | 数据表 |
| `fname` | string | 指定字段名，字符串 |
| `method` | string | ’>’，’<’，’<>’，’<=’，’>=’，’IN’，’IN2’，’IN3’ |
| `v1` | real | 实数 |
| `v2` | real | 实数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
return filterTableEx(t2, 'c', 'IN', 13, 30); // 取13<=[ 'c']<=30
```
## `floatN(r, n)`
声明：function
使用银行家算法进行四舍五入,精确到10Adigit位。“四舍六入五考虑，五后非零就进一，五后皆零看奇偶，五前为偶应舍去，五前为奇要进一”
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------ |
| `r` | real | 实数 |
| `n` | integer | 整型数据，保留的小数位数 |
返回：real
### 示例
```tsl
return floatN(12.6578, 2);
// 结果：12.66
```
## `floatToStrEx(r, n)`
声明：function
浮点->字符串
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------ |
| `r` | real | 实数 |
| `n` | integer | 整型数据，保留的小数位数 |
返回：string
### 示例
```tsl
return floatToStrEx (12.6578, 2);
// 结果：’ 12.66’
```
## `floatToStrne(value)`
声明：function
将实数转换成字符串类型。和FloatToStr的区别：在处理浮点数据时，FloatToStrne的结果不会输出为1E15等格式
| 参数 | 类型 | 说明 |
| ------- | ---- | ---- |
| `value` | real | 实数 |
返回：string
### 示例
```tsl
return floatToStrne(23.4);
// 输出字符串："23.4"
return floatToStrne(1E15);
// 大数量级数据，输出："1000000000000000"
```
## `floatToStrneW(value)`
声明：function
将实数转换成宽字节字符串类型。和FloatToStrW的区别：在处理大数量级数据（如1E15、10^15等）时，FloatToStrneW的结果不会输出为1E15等格式。
| 参数 | 类型 | 说明 |
| ------- | ---- | ---- |
| `value` | real | 实数 |
返回：string
### 示例
```tsl
return floatToStrneW(1234.1234);
// 输出：L"1234.1234"
return floatToStrneW(1E15);
// 大数量级数据，输出：L"1000000000000000"
```
## `footerAverage(t, from_col, tocol, average_col_field)`
声明：function
调用FooterValue对数组指定列求算术平均。
| 参数 | 类型 | 说明 |
| ------------------- | ------- | -------------------------- |
| `t` | array | 数据表类型，数据表 |
| `from_col` | integer | :整数，起始序号 |
| `tocol` | integer | 整数，截止序号 |
| `average_col_field` | string | 字符串，显示“平均”的列字段 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerAverage(s, 1, 3, '');
// 返回:
```
## `footerSum(t, from_col, tocol, average_col_field)`
声明：function
调用FooterValue对数组指定列求算术和。
| 参数 | 类型 | 说明 |
| ------------------- | ------- | -------------------------- |
| `t` | array | 数据表类型，数据表 |
| `from_col` | integer | :整数，起始序号 |
| `tocol` | integer | 整数，截止序号 |
| `average_col_field` | string | 字符串，显示“平均”的列字段 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerAverage(s, 1, 3, '');
// 返回:
```
## `footerValue(t, from_col, tocol, average_col_field, _type)`
声明：function
数组t从Fromcol列到ToCol列对每列求算术平均或者累计求和。
| 参数 | 类型 | 说明 |
| ------------------- | ------- | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `from_col` | integer | :整数，起始序号 |
| `tocol` | integer | 整数，截止序号 |
| `average_col_field` | string | 字符串，列名 |
| `_type` | any | 用户自定义 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6, 7));
return footerValue(s, 1, 3, '', 1);
// 返回:
```
## `formatFloatExt(v, dtype)`
声明：function
格式化输出－数字
| 参数 | 类型 | 说明 |
| ------- | ------- | ---------- |
| `v` | real | 实数 |
| `dtype` | integer | 数据的格式 |
返回：string
### 示例
```tsl
return formatFloatExt(12345.67, 1);
// 结果：’ 12,345.67’
return formatFloatExt("123");
// 结果：’ -’
```
## `formatStrExt(s)`
声明：function
判断字符串是否是字符串，不是字符串的显示为“-”
| 参数 | 类型 | 说明 |
| ---- | ------ | ------ |
| `s` | string | 字符串 |
返回：string
### 示例
```tsl
return formatStrExt('aaaaa');
// 结果：’aaaaa’
return formatStrExt(123);
// 结果：’-’
```
## `formatStrToDateTime2(s, format_str)`
声明：function
字符串->日期时间(包含毫秒)。
| 参数 | 类型 | 说明 |
| ------------ | ------ | ---------------------- |
| `s` | string | 字符串类型，时间字符串 |
| `format_str` | string | 字符串类型，格式字符串 |
返回：datetime
### 示例
```tsl
// 字符串2021-8-12 10:31:24:199 转换为日期时间格式(包含毫秒)
s := "2021.01.04T23:00:00.000";
format_str := "yyyy.mm.ddThh:nn:ss.zzz";
return formatStrToDateTime2(s, format_str); // 结果：44200.9583333333
```
## `Frame_addprefix(t, prefix, ifcopy)`
声明：function
数据表-数组下标批量加前缀 二维数组，对列名加前缀 一维数组，对行下标加前缀
| 参数 | 类型 | 说明 |
| -------- | ------ | -------------------------------------- |
| `t` | any | Table,源数组 |
| `prefix` | string | String,前缀 |
| `ifcopy` | bool | Bool,是否在拷贝后的数组改列名,默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addprefix(data, "pre_", true)));
```
## `Frame_addsuffix(t, suffix, ifcopy)`
声明：function
数据表-数组下标批量加后缀 二维数组，对列名加后缀 一维数组，对行下标加后缀
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------- |
| `t` | any | Table,源数组 |
| `suffix` | string | String,后缀 |
| `ifcopy` | bool | Bool,是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
data := array(("code": "A", "value": 1));
echo trim(toStn(Frame_addsuffix(data, "_new", true)));
```
## `frameconcat(arrdic, _type)`
声明：function
数据表-拼接
| 参数 | 类型 | 说明 |
| -------- | --------- | --------------------------------------------------------------- |
| `arrdic` | array | Array of number,数组的数组,需要拼接的数组集合 |
| `_type` | Usrdefine | Usrdefine,数组拼接方式，默认为0行并=0；列并=1；非完全矩阵列并=2 |
返回：array
### 示例
```tsl
a := ones(3,3);
b := ones(2,3);
frameconcat(array(a,b));
```
## `framecorrel(data)`
声明：function
数据表-相关系数矩阵
| 参数 | 类型 | 说明 |
| ------ | ----- | ----------------------------------------------- |
| `data` | table | Table,二维数据表，列名可为字符串,不支持一维数组 |
返回：array
### 示例
```tsl
arr := array(
("沪深300":-0.16,"中证500":-0.46,"中证1000":-0.72,"国债指数":0.06),
("沪深300":2.4,"中证500":2.38,"中证1000":2.77,"国债指数":0.02),
("沪深300":0.61,"中证500":1.84,"中证1000":2.14,"国债指数":0.03),
("沪深300":-0.22,"中证500":-0.26,"中证1000":-0.2,"国债指数":0.05),
("沪深300":1.01,"中证500":0.27,"中证1000":0.21,"国债指数":-0.0),
("沪深300":-0.19,"中证500":-0.16,"中证1000":-0.27,"国债指数":-0.02),
("沪深300":0.72,"中证500":0.77,"中证1000":0.85,"国债指数":0.0),
("沪深300":-0.87,"中证500":-0.66,"中证1000":-0.59,"国债指数":0.02),
("沪深300":1.96,"中证500":1.42,"中证1000":1.09,"国债指数":0.01),
("沪深300":0.02,"中证500":-0.24,"中证1000":-0.15,"国债指数":0.11));
return frameCorrel(arr);
```
## `framecov(data)`
声明：function
数据表-协方差
| 参数 | 类型 | 说明 |
| ------ | ----- | ------------------------------------------------ |
| `data` | table | Table,二维数据表，列名可为字符串。不支持一维数组 |
返回：array
### 示例
```tsl
arr := array(
("沪深300":-0.16,"中证500":-0.46,"中证1000":-0.72,"国债指数":0.06),
("沪深300":2.4,"中证500":2.38,"中证1000":2.77,"国债指数":0.02),
("沪深300":0.61,"中证500":1.84,"中证1000":2.14,"国债指数":0.03),
("沪深300":-0.22,"中证500":-0.26,"中证1000":-0.2,"国债指数":0.05),
("沪深300":1.01,"中证500":0.27,"中证1000":0.21,"国债指数":-0.0),
("沪深300":-0.19,"中证500":-0.16,"中证1000":-0.27,"国债指数":-0.02),
("沪深300":0.72,"中证500":0.77,"中证1000":0.85,"国债指数":0.0),
("沪深300":-0.87,"中证500":-0.66,"中证1000":-0.59,"国债指数":0.02),
("沪深300":1.96,"中证500":1.42,"中证1000":1.09,"国债指数":0.01),
("沪深300":0.02,"中证500":-0.24,"中证1000":-0.15,"国债指数":0.11));
return framecov(arr);
```
## `framecut(a, bins, option, o_lables)`
声明：function
从小到大分段分组，最小的为第0组
| 参数 | 类型 | 说明 |
| ---------- | ------- | --------------------------------------------------------------------------- |
| `a` | array | 数据表或一维数字数组，数据表时，表示对每列分别操作 |
| `bins` | array | 一维数字数组，分段节点，例如array(0,1)将数组a分为[-inf,0)[0,1)[1,inf)三段， |
| `option` | integer | 整型，区间开/闭，默认为0 |
| `o_lables` | integer | 数组，输出分组区间说明 |
返回：array
### 示例
范例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)
```
## `Framedrop_duplicates(data, subset, keep, rowname)`
声明：function
数据表-去重
| 参数 | 类型 | 说明 |
| --------- | ------ | --------------------------------------------------- |
| `data` | array | Table,二维数据表,源数据 |
| `subset` | string | String,去重字段 |
| `keep` | string | String,去重保留方法，""f"":保留首个，""l"":保留最后 |
| `rowname` | string | String,保留原索引重置字段名 |
返回：array
### 示例
```tsl
data := array(
("code": "A", "value": 1),
("code": "A", "value": 2),
("code": "B", "value": 3)
);
echo trim(toStn(Framedrop_duplicates(data, "code", "f", "source_index")));
```
## `Framedrop_na(data, how, subset)`
声明：function
数据表-去掉含Nan的行
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------------------------------------ |
| `data` | array | Table,二维数据表,源数据 |
| `how` | string | String,去na行方法，默认/1/""any"":任意，2/""all"":所有 |
| `subset` | string | String,去重字段 |
返回：array
### 示例
```tsl
data := array((nan, 8), (1, 3));
echo trim(toStn(Framedrop_na(data, "any", array(0))));
```
## `frameGetSubByReg(data, reg)`
声明：function
通过正则表达式匹配获取数据框子集
| 参数 | 类型 | 说明 |
| ------ | ------ | -------------------------- |
| `data` | array | 数组，待匹配的数组 |
| `reg` | string | 字符串，间隔名，正则匹配串 |
返回：array
### 示例
```tsl
t := array((13: 1, "V1": 1, "V2": 11, 12: 21, 'R1w': 1),
(13: 0, "V1": 2, "V2": 12, 12: 22, 'R1w': 1),
(13: 1, "V1": 3, "V2": 13, 12: 23, 'R1w': 1),
(13: 0, "V1": 4, "V2": 14, 12: 24, 'R1w': 1),
(13: 1, "V1": 5, "V2": 15, 12: 25, 'R1w': 1),
(13: 0, "V1": 6, "V2": 16, 12: 26, 'R1w': 1));
return frameGetSubByReg(t, '1');
// 结果：
// array(
// (21, 1, "V1": 1, "R1w": 1),
// (22, 0, "V1": 2, "R1w": 1),
// (23, 1, "V1": 3, "R1w": 1),
// (24, 0, "V1": 4, "R1w": 1),
// (25, 1, "V1": 5, "R1w": 1),
// (26, 0, "V1": 6, "R1w": 1))
```
## `framehhi(data)`
声明：function
数据表-HHI指数、赫芬达尔—赫希曼指数
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------- |
| `data` | table | Table,数组 |
返回：array
### 示例
```tsl
data := array(0.4, 0.3, 0.2, 0.1);
return framehhi(data); // HHI = 0.4^2+0.3^2+0.2^2+0.1^2
// 输出：0.3
```
## `frameIndex_filter(rawkeys, filter_cond, filter_type, dz_valuetokey)`
声明：function
数组筛选器，用于下标数组行名或列名的筛选器
| 参数 | 类型 | 说明 |
| --------------- | ------ | ---------------------------------------- |
| `rawkeys` | array | 一维字符串数组,下标数组(0开始的自增下标) |
| `filter_cond` | string | 字符串,筛选条件 |
| `filter_type` | any | 用户自定义,筛选类型 |
| `dz_valuetokey` | any | 整数,Out:类型1时，输出ivalue对照用 |
返回：array
### 示例
```tsl
columns := array("name", "period", "factor", "IC@mean", "IC@ratio");
echo trim(toStn(frameIndex_filter(columns, array("period", "factor"), 1)));
```
## `frameIndex_getilocDZ(raw_data_cols)`
声明：function
用于方便获取 下标值 与 字段位置 下标数组对照（下标值->下标位置）
| 参数 | 类型 | 说明 |
| --------------- | ----- | ---------------------------------------- |
| `raw_data_cols` | array | 一维字符串数组,下标数组(从0开始自增数组) |
返回：array
### 示例
```tsl
echo trim(toStn(frameIndex_getilocDZ(array("growth", "value", "momentum"))));
```
## `frameinsert(data, loc, fname, v)`
声明：function
数据表-指定位置插入列
| 参数 | 类型 | 说明 |
| ------- | ------- | ----------------------- |
| `data` | table | Table,二维数据表,源数据 |
| `loc` | integer | Integer,插入位置 |
| `fname` | string | String,插入索引命名 |
| `v` | integer | Integer,插入值 |
返回：array
### 示例
```tsl
data := array(
("SepalLength":4.6,"SepalWidth":3.1),
("SepalLength":5.0,"SepalWidth":3.6),
("SepalLength":5.4,"SepalWidth":3.9));
return frameinsert(data, 1, '新列', 0);
// 输出：
// array(
// ("SepalLength":4.6,"新列":0,"SepalWidth":3.1),
// ("SepalLength":5.0,"新列":0,"SepalWidth":3.6),
// ("SepalLength":5.4,"新列":0,"SepalWidth":3.9))
```
## `Framelag_zf(t, period, fillzero)`
声明：function
数据表-推移涨幅(%) 涨幅(%)算法： period>0: 前n期涨幅 r\[i\] := (t(i)/t(i-period)-1)\*100; period<0: 到未来n期涨幅 r\[i\] := (t(i-period)/t(i)-1)\*100; 注意period>0时，与framePct_change的结果一致。
| 参数 | 类型 | 说明 |
| ---------- | ----- | --------------------------------------- |
| `t` | array | Array of number,数据表，支持一维和二维 |
| `period` | any | Integer,移动期数，默认1 |
| `fillzero` | bool | Bool,下标越界是，是否返回0.False返回inf |
返回：array
### 示例
```tsl
echo trim(toStn(Framelag_zf(array(10, 5, 8, 2), 1, false)));
```
## `frameMelt(t, id_names, value_names, variable_sname, value_sname)`
声明：function
二维表——>立体表
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ------------------------------------------------------------------- |
| `t` | array | 二维字符串数组，数据表 |
| `id_names` | array | 一维字符串数组，键字段 |
| `value_names` | array | 一维字符串数组，值字段。为nil或者空时，表每行除开键字段外都是值字段 |
| `variable_sname` | string | 字符串，变量展示名 |
| `value_sname` | string | 字符串，值展示名 |
返回：array
### 示例
```tsl
t := array(
('截止日': 20210101, 'SH000300': 1, 'SH000301': 3),
('截止日': 20210102, 'SH000300': 9, 'SH000301': 2),
);
id_names := array('截止日');
return frameMelt(t, '截止日', nil, '代码', '得分');
```
## `framemerge(left, right, ons, how)`
声明：function
数据表-联结
| 参数 | 类型 | 说明 |
| ------- | ------ | --------------------------- |
| `left` | table | Table,左表 |
| `right` | table | Table,右表 |
| `ons` | string | String,联结字段，可以为数组 |
| `how` | string | String,: 联结类型 |
返回：array
### 示例
范例1：
```tsl
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
return framemerge(left, right, 'a');
// 输出：内连接，仅保留两表 a 均匹配的行(a=3,4)，重名列 a、b 加 _x/_y 后缀区分。
// array(
// ("a_x":3,"b_x":0.1,"a_y":3,"b_y":0.7,"c":30),
// ("a_x":4,"b_x":0.2,"a_y":4,"b_y":0.8,"c":40))
```
范例2
```tsl
// 多字段merge
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
left[: , 'c'] := left[: , 'a'];
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
right[: , 'c'] := right[: , 'a'];
names := array('a', 'c');
return framemerge(left, right, names, 'left', nil, true);
// 输出：按 a、c 两字段做左连接(how='left')，保留左表全部行(a=3,4,5)，重名列加 _x/_y 后缀。
// array(
// ("a_x":3,"b_x":0.1,"c_x":3,"a_y":3,"b_y":0.7,"c_y":3),
// ("a_x":4,"b_x":0.2,"c_x":4,"a_y":4,"b_y":0.8,"c_y":4),
// ("a_x":5,"b_x":0.3,"c_x":5))
```
范例3
```tsl
// 只更名right
left := `array('a': 3->5, 'b': array(0.1, 0.2, 0.3));
right := `array('a': 1->4, 'b': array(0.5, 0.6, 0.7, 0.8), 'c': array(10, 20, 30, 40));
return framemerge(left, right, 'a', 'full', array(nil, '_x'));
// 输出：全外连接(how='full')，保留两表所有 a；仅右表重名列加 '_x' 后缀(左表列名不变)。
// array(
// ("a":3,"b":0.1,"a_x":3,"b_x":0.7,"c":30),
// ("a":4,"b":0.2,"a_x":4,"b_x":0.8,"c":40),
// ("a":5,"b":0.3),
// ("a_x":1,"b_x":0.5,"c":10),
// ("a_x":2,"b_x":0.6,"c":20))
```
## `Framepct_change(t, period, fillzero)`
声明：function
数据表-到当期的变动百分比(%) 变动百分比(%)算法 r\[i\] := (t(i)/t(i-period)-1)\*100;
| 参数 | 类型 | 说明 |
| ---------- | ----- | ---------------------------------------- |
| `t` | array | Array of number,数据表，支持一维和二维 |
| `period` | any | Integer,变动期数，默认1 |
| `fillzero` | bool | Bool,下标越界是，是否返回0. False返回inf |
返回：array
### 示例
```tsl
echo trim(toStn(Framepct_change(array(10, 5, 8, 2), 1, false)));
```
## `framePivot_table(t, index, columns, vals, aggfunc, aggfuncnames)`
声明：function
分组、透视、汇总，类似可见Pivot_table
| 参数 | 类型 | 说明 |
| -------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `t` | any | 数据表类型,数据表 |
| `index` | string | 字符串,行分类字段，字段值含有nill等不可设为索引 |
| `columns` | array | 一维字符串数组,列分类字段，字段值含有nill等不可设为索引 |
| `vals` | array | 一维字符串数组,值字段，未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 |
| `aggfunc` | string | 字符串,值汇总函数,支持如下:；a、所有 TS_SQL 聚合函数:e.g:"avg"(avgof),"sum"(sumof)；b、内置函数:；"\_details": 分组详情；"\_first": 第一个；"\_last": 最后一个；c、自定义函数中使用关键字thisgroup 得到当前分组数据。 |
| `aggfuncnames` | array | 一维字符串数组,自定义汇总函数名称对照表 |
返回：array
### 示例
```tsl
data := array(
("group": "A", "date": "2025-01-01", "value": 1),
("group": "A", "date": "2025-01-02", "value": 2),
("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(framePivot_table(
data,
"group",
array("date"),
array("value"),
"sum",
nil
)));
```
## `frameqcut(data, q)`
声明：function
数据表-按频率分组(等频分组)
| 参数 | 类型 | 说明 |
| ------ | ------- | -------------------------------------------- |
| `data` | table | Table,数据表或一维数字数组，数据表时，表示对 |
| `q` | integer | Integer,分组数，等分q组，正整数，默认q=5 |
返回：array
### 示例
```tsl
data := array(1, 2, 3, 4, 5, 6, 7, 8, 9);
return frameqcut(data, 3); // 按大小等频分为 3 组，返回各元素所属组号(0,1,2)
// 输出：array(0,0,0,1,1,1,2,2,2)
```
## `frameupdate(left, right, ons, _type, _type)`
声明：function
数据表-更新
| 参数 | 类型 | 说明 |
| ------- | ------- | -------------------------------------------- |
| `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');
```
## `framevaluecounts(data, countfieldname, iforder)`
声明：function
数据表-计数
| 参数 | 类型 | 说明 |
| ---------------- | ------ | ------------------------------------ |
| `data` | table | Table,可以为二维数据表或者为一维数组 |
| `countfieldname` | string | String,计数字段名，默认为""个数"" |
| `iforder` | bool | Bool,是否排序，默认为真 |
返回：array
### 示例
```tsl
data := array("a", "b", "a", "c", "a", "b");
return framevaluecounts(data, "个数", true); // 统计各值出现次数，按次数降序
// 输出：
// array(
// ("值":"a","个数":3),
// ("值":"b","个数":2),
// ("值":"c","个数":1))
```
## `fuzzyCompare(_type, s1, s2)`
声明：function
根据指定算法，计算两字符串的相似性
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------ |
| `_type` | integer | 模糊匹配算法类型，支持如下几种算法： |
| `s1` | string | 字符串1 |
| `s2` | string | 字符串2 |
返回：real
### 示例
```tsl
// 使用Jaccard相似度算法，计算字符串"kitten"和"sitting"的相似性
return fuzzyCompare(fzJaccard(), "kitten", "sitting"); // 等价于FuzzyCompare(2,"kitten","sitting")
// 返回：0.222222222222222
```
## `fuzzyCompareEx(_type, s1, s2, n, nret)`
声明：function
根据指定算法，计算两字符串的相似性
| 参数 | 类型 | 说明 |
| ------- | ------- | ---------------------------------------------------------------------------------- |
| `_type` | integer | 模糊匹配算法类型，支持如下几种算法： |
| `s1` | string | 字符串1 |
| `s2` | string | 字符串2 |
| `n` | integer | 仅指定算法为FzJaccard、FzCosine、FzSimHash时，该参数有效；其对应含义和默认值如下： |
| `nret` | integer | 输出值；指定不同的算法时，其对应含义如下： |
返回：real
### 示例
```tsl
// 使用Jaccard相似度算法，指定切分字符长度为1，计算字符串"kitten"和"sitting"的相似性
t := fuzzyCompareEx(fzJaccard(), "kitten", "sitting", 1, nret);
return array(t, nret);
// t值为相似性，nret值为两字符串切分后交集中元素个数，返回值为array(0.428571428571429,3)
```
## `fzCosine()`
声明：function
Cosine（余弦相似度）算法类型：将字符串根据指定长度n（默认值为2）划分为两个字符集合，将字符集合转换为向量，计算两向量夹角的余弦值。
返回：integer
### 示例
范例一：FuzzyCompare相似性计算，字符切分长度为2
```tsl
return fuzzyCompare(fzCosine(), "kitten", "sitting");
// 返回：0.365148371670111
```
范例二：FuzzyCompareEx相似性计算，指定字符切分长度为1
```tsl
return fuzzyCompareEx(fzCosine(), "kitten", "sitting", 1, nret);
// 返回：0.746202507244636
// 算法对比解析：
// FuzzyCompare：字符切分长度为2，字符串"kitten"切分后的集合为：{ki, it, tt, te, en}，"sitting"：{si, it, tt, ti, in, ng}；转换成向量分别为：[1, 1, 1, 1, 1, 0, 0, 0, 0]、[0, 1, 1, 0, 0, 1, 1, 1, 1]，代入算法中，计算出的相似度为0.365148371670111
// FuzzyCompareEx：字符切分长度为1，字符串"kitten"切分后的集合为：{k, i, t, e, n}，"sitting"：{s, i, t, n, g}，转换成向量分别为：[1, 1, 2, 1, 1, 0, 0]、[0, 2, 2, 0, 1, 1, 1]，代入算法中，计算出的相似度为0.746202507244636
```
## `fzEditDistance()`
声明：function
基于编辑距离（Edit Distance）的模糊匹配算法，核心是计算将一个字符串转换为另一个字符串所需的最小编辑操作次数，允许的操作包含插入、删除、替换三类。
返回：integer
### 示例
范例一：FuzzyCompare相似性计算
```tsl
return fuzzyCompare(fzEditDistance(), "kitten", "sitting");
// 返回：0.571428571428571
```
范例一：FuzzyCompareEx相似性计算
```tsl
t := fuzzyCompareEx(fzEditDistance(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.571428571428571,3)
// 算法对比解析：
// 字符串"kitten"转换为"sitting"需要3步（k->s，e->i，添加g），字符串总长度7，相似度为1-3/7=4/7（即0.571428571428571）
```
## `fzHammingDistance()`
声明：function
Hamming Distance（汉明距离）算法类型：计算两字符串对应位置上不同字符的数量。
返回：integer
### 示例
范例一：FuzzyCompare相似性计算
```tsl
return fuzzyCompare(fzHammingDistance(), "kitten", "sitting");
// 返回：0.571428571428571
```
范例二：FuzzyCompareEx相似性计算
```tsl
t := fuzzyCompareEx(fzHammingDistance(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.571428571428571,3)
// 算法对比解析：
// 字符串"kitten"、"sitting"对应位置上不同的字符有3处（k->s, e->i, g），字符串总长度为7，相似度为1-3/7=4/7（即0.571428571428571）
```
## `fzJaccard()`
声明：function
Jaccard相似度算法类型：将字符串根据指定长度n（默认值为2）划分为两个字符集合，计算两集合交集元素个数与并集元素个数的比值。
返回：integer
### 示例
范例一：FuzzyCompare相似性计算，字符切分长度为2
```tsl
return fuzzyCompare(fzJaccard(), "kitten", "sitting");
// 返回：0.222222222222222
```
范例二：FuzzyCompareEx相似性计算，指定字符切分长度为1
```tsl
t := fuzzyCompareEx(fzJaccard(), "kitten", "sitting", 1, nret);
return array(t, nret);
// 返回：array(0.428571428571429,3)
// 算法对比解析：
// FuzzyCompare：字符切分长度为2，字符串"kitten"切分后的集合为：{ki, it, tt, te, en}，"sitting"为：{si, it, tt, ti, in, ng}；交集：{it, tt}，并集：{ki, it, tt, te, en, si, ti, in, ng}，相似度为2/9（即0.222222222222222）
// FuzzyCompareEx：指定字符切分长度为1，字符串"kitten"切分后的集合为：{k, i, t, e, n}，"sitting"为：{s, i, t, n, g}，交集：{i, t, n}，并集：{k, i, t, e, n, s, g}，相似度为3/7（即0.428571428571429）
```
## `fzJaroWinkler()`
声明：function
Jaro-Winkler距离算法类型：先统计两字符串的匹配字符数与换位次数，并代入Jaro距离算法公式，得到相似度，再根据两字符串的公共前缀长度给予额外加权，得到最终的相似度
返回：integer
### 示例
范例一：FuzzyCompare相似性计算
```tsl
return fuzzyCompare(fzJaroWinkler(), "kitten", "sitting");
// 返回：0.746031746031746
```
范例二：FuzzyCompareEx相似性计算
```tsl
return fuzzyCompareEx(fzJaroWinkler(), "kitten", "sitting", n, nret);
// 返回：0.746031746031746
```
## `fzLongestSequnce()`
声明：function
Longest Sequnce（最长公共子序列）算法类型：找出两字符串中顺序相同但不必连续的最长子序列
返回：integer
### 示例
范例一：FuzzyCompare相似性计算
```tsl
return fuzzyCompare(fzLongestSequnce(), "kitten", "sitting");
// 返回：0.571428571428571
```
范例二：FuzzyCompareEx相似性计算
```tsl
t := fuzzyCompareEx(fzLongestSequnce(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.571428571428571,4)
// 算法对比解析：
// 字符串"kitten"、"sitting"中顺序相同但不必连续的最长子序列为"ittn"，字符串总长度为7，相似度为4/7（即0.571428571428571）
```
## `fzLongestSubstring()`
声明：function
Longest Substring（最长公共子串）算法类型：找出两字符串中连续出现的最长相同子串。
返回：integer
### 示例
范例一：FuzzyCompare相似性计算
```tsl
return fuzzyCompare(fzLongestSubstring(), "kitten", "sitting");
// 返回：0.428571428571429
```
范例二：FuzzyCompareEx相似性计算
```tsl
t := fuzzyCompareEx(fzLongestSubstring(), "kitten", "sitting", n, nret);
return array(t, nret);
// 返回：array(0.428571428571429,3)
// 算法对比解析：
// 字符串"kitten"、"sitting"中连续出现的最长相同子串为"itt"，字符串总长度为7，相似度为3/7（即0.428571428571429）
```
## `fzSimHash()`
声明：function
SimHash（局部敏感哈希）算法类型：对字符串分词并计算加权哈希生成二进制指纹，比较两个指纹间的对应位置上不同字符的数量
返回：integer
### 示例
范例一：FuzzyCompare相似性计算，特征词数量为3
```tsl
return fuzzyCompare(fzSimHash(), "kitten", "sitting");
// 返回：0.640625
```
范例二：FuzzyCompareEx相似性计算，特征词数量为1
```tsl
t := fuzzyCompareEx(fzSimHash(), "kitten", "sitting", 1, nret);
return array(t, nret);
// 返回：array(0.921875,5)
```
## `geoMeanByColumn(t, f_name)`
声明：function
指定列的几何平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return geoMeanByColumn(t1, 'b');
// 结果：4.47
```
## `get_dummies(a, uniques)`
声明：function
1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、如果a中含Nan值，排到uniques的末尾
| 参数 | 类型 | 说明 |
| --------- | ----- | ----------------------------------------- |
| `a` | array | 一维数组，指定的分类变量 |
| `uniques` | array | 一维数组，中间结果:输出各列对应的分类变量 |
返回：array
### 示例
```tsl
data := array("A", "B", "C", "A");
encoded := get_dummies(data, categories);
echo trim(toStn(array("categories": categories, "encoded": encoded)));
```
## `get_dummies2(a)`
声明：function
1、根据指定的分类变量，生成虚拟变量/指示变量（dummy/indicator）虚设变量/名义变量/哑 变量，也有称之为one_hot编码，离散特征值二值化 2、a中的元素必须都可以做为数组下标，否则请使用get_dummies
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------ |
| `a` | array | 一维数组，指定的分类变量 |
返回：array
### 示例
```tsl
echo trim(toStn(get_dummies2(array("A", "A", "B", "C"))));
```
## `getBottomN(t, n)`
声明：function
取数组后N行，一般先用SortByField排序，然后使用此函数
| 参数 | 类型 | 说明 |
| ---- | ------- | ------ |
| `t` | array | 数据表 |
| `n` | integer | 整数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getBottomN(t2, 2);
```
## `getDistinctValue(t, f_name)`
声明：function
得到指定列唯一值，返回值为一维数组
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return getDistinctValue(t2, 'a');
```
## `getMiddleN(t, from_no, to_no)`
声明：function
取数组指定行区间记录，一般先用SortByField排序，然后使用此函数
| 参数 | 类型 | 说明 |
| --------- | ------- | ---------------------- |
| `t` | array | 数据表 |
| `from_no` | integer | 起始行数:整数，从1开始 |
| `to_no` | integer | 截止行数:整数，从1开始 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 4, 'c': 33), ('a': 5, 'c': 33));
return getMiddleN(t2, 2, 3);
```
## `getMsgDigest(arg)`
声明：function
信息摘要函数相关函数。
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------------------------------------------------------------------------------ |
| `arg` | string | 要计算摘要的字符串 |
| `digest_type` | int | 摘要算法编号：`0` CRC32，`1` MD5，`2` SHA1，`3` SHA224，`4` SHA256，`5` SHA384，`6` SHA512 |
| `alias` | string | 文件所在目录别名；不用别名时传空字符串 |
| `filename` | int | 要计算摘要的文件路径 |
| `digest_type` | any | 摘要算法编号：`0` CRC32，`1` MD5，`2` SHA1，`3` SHA224，`4` SHA256，`5` SHA384，`6` SHA512 |
返回：string
## `getPyStringList()`
声明：function
汉字拼音首字母对照表
返回：tslobj
### 示例
```tsl
sl := getPyStringList();
return sl.values("明");
// 返回：M
```
## `getSubField(t, field)`
声明：function
取表中某一字段的全部列值
| 参数 | 类型 | 说明 |
| ------- | ------ | ------------------- |
| `t` | array | 二维数组 |
| `field` | string | 列标名，字符串/整数 |
返回：array
### 示例
```tsl
a := array(('a': 8, 'b': 7), ('a': 6, 'b': 9));
return getSubField(a, 'a'); // 从a表中取第’a列’
```
## `getSubTable(table, field_arr)`
声明：function
将一个表类型数组只保留指定的字段并返回
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------- |
| `table` | array | 二维数组 |
| `field_arr` | array | 列标名，一维数组 |
返回：array
### 示例
```tsl
a := array((1, 2, 4), (11, 12, 14));
b := array(0, 2);
return getSubTable(a, b);
```
## `getSubTableByField(t)`
声明：function
获取表t中的Fields 列的数据。该函数功能可以用子矩阵的方式实现:t[:,array(fn1,fn2...)]
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------ |
| `t` | array | 数据表类型，数据表 |
返回：any
### 示例
```tsl
r := array(
("time":"2026-07-03","close":10.29,"open":10.29,"high":10.4),
("time":"2026-07-06","close":10.5,"open":10.25,"high":10.52),
("time":"2026-07-07","close":10.47,"open":10.46,"high":10.51),
("time":"2026-07-08","close":10.6,"open":10.44,"high":10.63),
("time":"2026-07-09","close":10.49,"open":10.55,"high":10.59));
return getSubTableByField(r, 'time;close');
// 功能相当于使用子矩阵取数：r[: , array('time', 'close')]
// 返回:
// array(
// ("time":"2026-07-03","close":10.29),
// ("time":"2026-07-06","close":10.5),
// ("time":"2026-07-07","close":10.47),
// ("time":"2026-07-08","close":10.6),
// ("time":"2026-07-09","close":10.49))
```
## `getSubTableByKey(t, key_field, return_fields)`
声明：function
将字符串KeyField以分号分隔,在数组t中从列ReturnFields匹配被分割的值,若找到则返回该行信息，否则返回空数组。
| 参数 | 类型 | 说明 |
| --------------- | ------ | ------------------------ |
| `t` | array | 数据表类型，数据表 |
| `key_field` | string | 字符串，关键字字段 |
| `return_fields` | string | 字符串，要返回的字段名称 |
返回：array
### 示例
```tsl
s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
array('A': 'c', 'B': 3, 'C': 4, 'D': 5, 'e': 6),
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7));
return getSubTableByKey(s, 'A', 'a;c');
// 返回:
```
## `getSubTableFreeParam()`
声明：function
取子表，系统第二个到最个一个参数为字段序列，取第一个参数中字段与字段序列匹配的列数据。
返回：array
### 示例
```tsl
return getSubTableFreeParam(); // 之前在系统参数中已经设置好第一个参数s=array(array('s':1,'w':2,'sl':3), array('s':2,'w':3,'sl':4), array('s':3,'w':4,'sl':5)),第二三个参数’s’,’w’。
// 返回:
```
## `getTopN(t, n)`
声明：function
取数组前N行记录，一般先用SortByField排序，然后使用此函数
| 参数 | 类型 | 说明 |
| ---- | ------- | ------ |
| `t` | array | 数据表 |
| `n` | integer | 整数 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 33));
return getTopN(t2, 2);
```
## `getValuesByFieldValue(t, f_name, field_value)`
声明：function
返回指定字段值等于指定值的所有记录
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------- |
| `t` | array | 二维数组 |
| `f_name` | string | 字符串，指定字段 |
| `field_value` | string | 整数/字符串，指定值 |
返回：array
### 示例
```tsl
t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return getValuesByFieldValue(t, 'b', 4); // 返’b’列值为4的所有记录
```
## `groupByFieldValue(t, group_field, lowvalue, high_value, sep_value)`
声明：function
按字段大小进行汇总。小于最小值Lowvalue为一组，从最小值Lowvalue到最大值HighValue中间每步长SepValue为一组，大于最大值High为一组。
| 参数 | 类型 | 说明 |
| ------------- | ------ | -------------- |
| `t` | array | 数据表类型 |
| `group_field` | string | 字符串，列名 |
| `lowvalue` | real | 实数，最小数值 |
| `high_value` | real | 实数，最大数值 |
| `sep_value` | real | 实数，统计间距 |
返回：any
### 示例
```tsl
data := select * from tradetable datekey 20180903t to 20180904T of 'sz000001' end;
return groupByFieldValue(data, 'close', 1, 20, 0.1);
// 返回:
```
## `groupDemeanIt(t, g_name, v_name)`
声明：function
1、分组去均值，对数据表t按[GName]分组后，对每组的[VName]去均值
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------ |
| `t` | dbdata | 数据表，待分组去均值数据 |
| `g_name` | string | 字符串，t的分组字段名 |
| `v_name` | string | 字符串，去均值字段名 |
返回：array
### 示例
范例1：
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupDemeanIt(t, 'G', 'V1'); // array(-2.0,-2.0,0.0,0.0,2.0,2.0)
```
范例2
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupDemeanIt(t, 'G', array('V1', 'V2'));
// 输出：
// array(
// ("V1":-2.0,"V2":-2.0),
// ("V1":-2.0,"V2":-2.0),
// ("V1":0.0,"V2":0.0),
// ("V1":0.0,"V2":0.0),
// ("V1":2.0,"V2":2.0),
// ("V1":2.0,"V2":2.0))
```
## `groupPercentrankIt(t, g_name, v_name)`
声明：function
计算分组百分位，对数据表t按[GName]分组后，对每组的[Vname_]计算百分位
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------ |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串，转换字段名 |
返回：array
### 示例
```tsl
t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupPercentrankIt(t, 'G', 'V1'); // array(0.0,0.0,0.5,0.5,1.0,1.0)
```
## `groupRankIt(t, g_name, v_name, sort_order)`
声明：function
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]计算排名
| 参数 | 类型 | 说明 |
| ------------ | ------ | ------------------ |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串，转换字段名 |
| `sort_order` | bool | 布尔型，排名方向 |
返回：array
### 示例
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupRankIt(t, 'G', 'V1'); // array(1,1,2,2,3,3)
```
## `groupTransformByFunc(t, g_name, v_name, fp)`
声明：function
计算分组排名，对数据表t按[GName]分组后，对每组的[Vname_]根据给定函数进行分组转换操作
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------------------------------------------- |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串或数组，转换字段名 |
| `fp` | string | 字符串（函数名）或函数指针，转换函数必须两个参数，分别表示当前的聚合字段与排名字段，以分组排名为例: |
返回：array
### 示例
```tsl
t := array(("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
fp := function (v, g);
begin
return rankof([v], [v]);
end
return groupTransformByFunc(t, 'G', 'V1', fp); // array(3,3,2,2,1,1)
```
## `groupZscoreIt(t, g_name, v_name)`
声明：function
1.计算分组标准化，对数据表t按[GName]分组后，对每组的[Vname_]进行标准化(原值-分组平均)/分组标准差
| 参数 | 类型 | 说明 |
| -------- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
| `t` | array | 数组，待计算的数组 |
| `g_name` | string | 字符串，分组字段名 |
| `v_name` | string | 字符串，转换字段名。如果Vname*为nil则表示除GName之外的所有字段，如果Vname*为一个数组，则表示需要计算的字段组返回:二维数组， |
返回：array
### 示例
```tsl
t := array(
("G": 1, "V1": 1, "V2": 11, "V3": 21),
("G": 0, "V1": 2, "V2": 12, "V3": 22),
("G": 1, "V1": 3, "V2": 13, "V3": 23),
("G": 0, "V1": 4, "V2": 14, "V3": 24),
("G": 1, "V1": 5, "V2": 15, "V3": 25),
("G": 0, "V1": 6, "V2": 16, "V3": 26));
return groupZscoreIt(t, 'G', 'V1'); // array(-1.0,-1.0,0.0,0.0,1.0,1.0)
```
## `harMeanByColumn(t, f_name)`
声明：function
指定列的调和平均值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 5, 'c': 5));
return harMeanByColumn(t1, 'b');
// 结果：4.44
```
## `histogram(t, bins, format)`
声明：function
统计data的频数分布表
| 参数 | 类型 | 说明 |
| -------- | ---------------- | --------------------------------------- |
| `t` | array,tablearray | 数字数组，待计算的数组 |
| `bins` | array,tablearray | 数组，表分组间隔 |
| `format` | string | 字符串，展示区间的格式串，见FormatFloat |
返回：array,tablearray
### 示例
范例一：
```tsl
return histogram(Randn(0, 1, 1000), array(-3, 0.5)->3, '0.00');
// 输出：频数分布表。区间列(<=-3.00、-3.00~-2.50 …… 2.50~3.00、>3.00)与区间中位数列固定，
// 但因 Randn 生成的是随机正态样本，各区间的频数、频率(%)、累计频率(%)每次运行都不同。
```
范例二：
```tsl
data := randn(0, 1, 1000, array('a', 'b'));
return histogram(data, array(-3, 0.5)->3, '0.00');
// 输出：多列频数分布表。data 为两列(a、b)随机正态样本，结果按列给出 a@频数、a@频率(%)、
// a@累计频率(%)、b@频数 …… 等列。区间划分固定，但各频数因随机样本每次运行都不同。
```
## `hztoPy(hz)`
声明：function
汉字翻译为拼音
| 参数 | 类型 | 说明 |
| ---- | ------ | ----------- |
| `hz` | string | String 汉字 |
返回：string
### 示例
```tsl
return hztoPy("华夏优势"); // HXYS
return hztoPy("华夏盛势"); // HXCS HXSS
```
## `ifsparse(s)`
声明：function
判断是否为稀疏矩阵。检查条件：只检查下标，下标全为大于等于0的整数。
| 参数 | 类型 | 说明 |
| ---- | ------------- | ---------- |
| `s` | array of real | 待判断矩阵 |
返回：integer
### 示例
```tsl
// 判断矩阵S是否为稀疏矩阵
s := Array(3: 2, "B": 3);
return ifsparse(s); // 返回0
```
## `importFile(filename, arg2, arg3, data2)`
声明：function
文件访问函数相关函数。
| 参数 | 类型 | 说明 |
| ---------- | ------ | ---- |
| `filename` | int | |
| `arg2` | string | |
| `arg3` | array | |
| `data2` | bool | |
返回：bool
## `in1(v, x)`
声明：function
判断数值x是否在数组v中，返回布尔类型
| 参数 | 类型 | 说明 |
| ---- | ----- | -------- |
| `v` | array | 一维数组 |
| `x` | real | 实数 |
返回：bool
### 示例
```tsl
a := array(1, 2, 3, 4);
return in1(a, 3);
// 结果：1
```
## `incHalfYear(a_value, number)`
声明：function
求Avalue的日期开始往后推移Number个半年的日期
| 参数 | 类型 | 说明 |
| --------- | --------- | -------------------------------- |
| `a_value` | tdatetime | 实数表示的日期 |
| `number` | integer | 向后推移的整数，负数表示向前推移 |
返回：tdatetime
### 示例
```tsl
avalue := 40179; // 40179表示2010年1月1号
number := 2;
return incHalfYear(a_value, number);
// 结果：40544 //40544表示2011年1月1号
```
## `incQuarter(avalue, number)`
声明：function
求Avalue的日期开始往后推移Number个季度的日期
| 参数 | 类型 | 说明 |
| -------- | --------- | ---------------------------------- |
| `avalue` | tdatetime | 实数表示的日期 |
| `number` | integer | 向后推移的整数。负数表示向前推移。 |
返回：tdatetime
### 示例
```tsl
avalue := 40179; // 40179表示2010年1月1号
number := 2;
return incQuarter(a_value, number);
// 结果：40360 //40360表示2010年7月1号
```
## `iniDeleteKey(alias, file_name, section, ident)`
声明：function
删除INI中的标识符。
| 参数 | 类型 | 说明 |
| ----------- | ------ | ----------------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件中的节名称 |
| `ident` | string | 字符串类型。INI文件中要删除的键名称 |
返回：any
## `iniWriteBool(alias, file_name, section, ident, value)`
声明：function
将BOOL值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将Bool值Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | ------ | --------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | bool | object |
返回：string
## `iniWriteDate(alias, file_name, section, ident, value)`
声明：function
将日期值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将日期值Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | -------- | --------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | datetime | 日期类型。要写入的日期值 |
返回：string
## `iniWriteDateTime(alias, file_name, section, ident, value)`
声明：function
将日期时间值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将日期时间值Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | -------- | -------------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | datetime | 日期时间类型。要写入的日期时间值 |
返回：string
## `iniWriteFloat(alias, file_name, section, ident, value)`
声明：function
将浮点值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将浮点值Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | ------ | --------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | float | 浮点类型。要写入的浮点数值 |
返回：string
## `iniWriteInteger(alias, file_name, section, ident, value)`
声明：function
将整数值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将整数值Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | ------ | --------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | float | 整数类型。要写入的整数值 |
返回：string
## `iniWriteString(alias, file_name, section, ident, value)`
声明：function
将字符串值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将字符串Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | ------ | --------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | string | 字符串类型。要写入的字符串 |
返回：string
## `iniWriteTime(alias, file_name, section, ident, value)`
声明：function
将时间值写入INI。如果不存在FileName，或者不存在Section，或者不存在Ident，则其会根据输入的FileName，Section，Ident创建对应的INI文件，INI文件的节名称，INI文件的键名称，并将时间值Value写入到INI文件指定的键
| 参数 | 类型 | 说明 |
| ----------- | -------- | --------------------------- |
| `alias` | string | 字符串类型。目录名称 |
| `file_name` | string | 字符串类型。INI文件名称 |
| `section` | string | 字符串类型。INI文件的节名称 |
| `ident` | string | 字符串类型。INI文件的键名称 |
| `value` | datetime | 时间类型。要写入的时间值 |
返回：string
## `inRange(a_value, amin, amax)`
声明：function
判断Avalue是否在\[Amin, Amax\]范围内
| 参数 | 类型 | 说明 |
| --------- | ----- | -------------- |
| `a_value` | float | 要判断的实数 |
| `amin` | float | 实数，范围下限 |
| `amax` | float | 实数，范围上限 |
返回：bool
## `inserttablebyrno(t, index, rdata)`
声明：function
向表格指定位置插入行，天软表格行下标从0开始
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------------------------------ |
| `t` | array | Array,数组，支持一维，二维数组，只支持下标为自增长的序列数组 |
| `index` | integer | Integer,插入行的起始下标，下标位置从０开始 |
| `rdata` | any | Any,插入的数据，支持一个值、一维表及二维表 |
返回：array
### 示例
范例1：
```tsl
// 向一维数组指定位置插入一个字符串’aaa’
t := 43456->43460;
index := 2;
r_data := 'aaa';
return inserttablebyrno(t, index, r_data);
// 结果：array(43456,43457,"aaa",43458,43459,43460)
```
范例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);
// 输出：
// array(
// ("a":10,"b":"i","c":"2020-03-19"),
// ("a":50,"b":"i","c":"2020-03-18"),
// ("a":60,"b":"i","c":"2020-03-17"),
// ("c":0,"b":44000,"a":"2020-03-20"),
// ("a":40,"b":"o","c":"2020-03-16"),
// ("a":20,"b":"o","c":"2020-03-13"))
```
范例4：
```tsl
// 向二维数组第1行插入多行的数据
t := array(('a': 10, 'b': 'i', 'c': dateToStr(20200319T)),
('a': 50, 'b': 'i', 'c': dateToStr(20200318T)),
('a': 60, 'b': 'i', 'c': dateToStr(20200317T)),
('a': 40, 'b': 'o', 'c': dateToStr(20200316T)),
('a': 20, 'b': 'o', 'c': dateToStr(20200313T)));
index := 1;
r_data := array(('c': '2020', 'b': 'AAA', 'a': 44456),
('c': '2020', 'b': 'BBB', 'a': 44566));
return inserttablebyrno(t, index, r_data);
// 输出：
// array(
// ("a":10,"b":"i","c":"2020-03-19"),
// ("c":"2020","b":"AAA","a":44456),
// ("c":"2020","b":"BBB","a":44566),
// ("a":50,"b":"i","c":"2020-03-18"),
// ("a":60,"b":"i","c":"2020-03-17"),
// ("a":40,"b":"o","c":"2020-03-16"),
// ("a":20,"b":"o","c":"2020-03-13"))
```
## `intersectionPart(v, w)`
声明：function
求交集
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `v` | array | 数组 |
| `w` | array | 数组 |
返回：array
### 示例
```tsl
t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return intersectionPart(t1, t2);
```
## `inverseTable(t)`
声明：function
将数组t去掉第一列转置，转置后原数组t的第一列作为行标。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------- |
| `t` | array | 数据表类型 |
返回：array
### 示例
```tsl
s := array(array('A': 'a', 'B': 'b', 'C': 'c', 'D': 'd', 'e': 'e'),
array('A': 2, 'B': 3, 'C': 4, 'D': 5, 'e': 6),
array('A': 3, 'B': 4, 'C': 5, 'D': 6, 'e': 7),);
return inverseTable(s);
// 返回:
```
## `istable(t)`
声明：function
判断是否为数组。如果t为数据表，返回True；否则，返回False
| 参数 | 类型 | 说明 |
| ---- | ----- | ------ |
| `t` | array | 数据表 |
返回：bool
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return istable(t1);
// 结果：1
```
## `isValidDateDay(a_year, aday_of_year)`
声明：function
判断参数指定的年以及此年的第ADayOfYear天是否是有效日期。返回值类型是布尔型真假值 所谓有效，意味着： 年Ayear介于1和9999之间 ADayOfYear介于1和指定Ayear年的最大天数
| 参数 | 类型 | 说明 |
| -------------- | ---- | ------------------------------ |
| `a_year` | int | 整数，年，指定的年份 |
| `aday_of_year` | int | 整数，表示在指定年份中的第几天 |
返回：bool
## `kurtByColumn(t, f_name)`
声明：function
指定列的峰度
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return kurtByColumn(t2, 'c');
// 结果：0.34
```
## `leftStr(text, num_chars)`
声明：function
返回字符串从开始向左数Num_Chars个字符组成的字符串，支持多字节语言，一个汉字当成一个字符。
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------- |
| `text` | string | 字符串 |
| `num_chars` | int | 字符个数 |
返回：string
## `letters(vlaue, ul)`
声明：function
将数字与在字符串进行对照转换。基本用法同R的letters。在超出26的时候，仿excel的列名的规则提取。用于将excel数字列名转为字符串列名：1->'A'。
| 参数 | 类型 | 说明 |
| ------- | ------- | ----------------------- |
| `vlaue` | integer | 整数。正整数列名 |
| `ul` | integer | 整数。是否大写，默认为1 |
返回：string/array
### 示例
```tsl
return letters(1, 0);
// 结果：a
```
## `maxValueByColumn(t, f_name)`
声明：function
求指定列中的最大值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return maxValueByColumn(t2, 'c');
// 结果：53
```
## `medianByColumn(t, f_name)`
声明：function
指定列的中位数
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return medianByColumn(t2, 'c');
// 结果：38
```
## `mergeArray(v1, v2, ...)`
声明：function
多个数组进行合并
| 参数 | 类型 | 说明 |
| ----- | ----- | ---- |
| `v1` | array | |
| `v2` | array | |
| `...` | | |
返回：array
### 示例
```tsl
t1 := array(('b': 12, 'a': 1, 'c': 13, 'd': 'd'));
t2 := array(('a': 2, 'b': 22, 'c': 23, 'e': 'ee'));
t3 := array(('a': 2, 'b': 22, 'd': 23, 'e': 'ee'));
return mergeArray(t1, t2, t3); // 将数组t1,t2,t3合并
```
## `milliSecondSpan()`
声明：function
范围生成函数相关函数。
返回：float
## `minValueByColumn(t, f_name)`
声明：function
求指定中的最小值
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return minValueByColumn(t2, 'c');
// 结果：13
```
## `nonIntersectionPart(t1, t2, key_field)`
声明：function
求差集(返回在t1中存在，而在t2中不存在的记录)
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------ |
| `t1` | array | 数据表 |
| `t2` | array | 数据表 |
| `key_field` | string | 指定某一字段 |
返回：array
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
t2 := array(('a': 1, 'b': 1), ('a': 7, 'b': 8), ('a': 5, 'b': 5));
return nonIntersectionPart(t1, t2, 'b');
// 输出：
// array(3,4)
```
## `noRecordTable()`
声明：function
返回一个空数组
返回：array,tablearray
### 示例
```tsl
return noRecordTable();
// 结果：Array()
```
## `normalTabletoStrSubscript(t, key_field)`
声明：function
索引下标数组-->字符串下标数组。将keyfield列的值变为行标。
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------------ |
| `t` | array | 数据表类型 |
| `key_field` | string | 字符串，列名 |
返回：any
### 示例
```tsl
s := nDay(10, 'time', dateToStr(sp_time()), 'close', close());
return normalTabletoStrSubscript(s, 'time');
// 把 time列的数据变为行标
---变为--》
```
## `outPutTableToCanBeUnderstood(t)`
声明：function
判断一个数据表是否是空值，如果是则返回'返回结果为空'，否则返回该数组。
| 参数 | 类型 | 说明 |
| ---- | ----- | -------------- |
| `t` | array | 数组，数据表。 |
返回：string|array
### 示例
```tsl
return outPutTableToCanBeUnderstood(array(1, 2, 3));
// 返回:
```
## `parseRegExpr3(s, reg_from_text, to_text, parse_ctrls)`
声明：function
直接返回输出的正则表达式解析。
| 参数 | 类型 | 说明 |
| --------------- | ------ | -------------------------------- |
| `s` | string | 字符串。源串 |
| `reg_from_text` | string | 字符串。待替换的部分，正则表达式 |
| `to_text` | string | 字符串。替换的字符串 |
| `parse_ctrls` | string | 字符串。正则表达式控制串 |
返回：string
### 示例
```tsl
return parseRegExpr3("abcdeak", "ab", "kkkk", "ir");
// 结果：kkkkcdeak
```
## `passwordGen(len, n, head, start)`
声明：function
密码生成器
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------------------------ |
| `len` | integer | 整数，密码长度 |
| `n` | integer | 整数，生成的密码组合数 |
| `head` | string | 字符串，用户名的前缀 |
| `start` | integer | 整数，用户名的后缀序列数字的起始数字 |
返回：array
### 示例
```tsl
return rdo2 passwordGen(8, 5, 'ts', 3);
// 返回:
```
## `percentValueByField(t, key_field, quart)`
声明：function
数据集在指定百分位数上对应的数值
| 参数 | 类型 | 说明 |
| ----------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `key_field` | string | 指定列名，字符串 |
| `quart` | real | 指定分位数，实数 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return percentValueByField(t2, 'c', 0.1);
// 结果：19
```
## `pivot(t, index, columns, vals)`
声明：function
透视，数据透视表
| 参数 | 类型 | 说明 |
| --------- | --------------- | -------------------------------------------------------------------------------------------------------- |
| `t` | array | 二维数组，待透视表，t[:,array(index,columns)] 不能包含重复的行，即index，columns 必须可以作为t的唯一主键 |
| `index` | string \| array | 字符串或一维字符串数组，行分类字段，t的列名，多个字段可以用数组，为nil表示取t的行下标 |
| `columns` | string \| array | 字符串或一维字符串数组，列分类字段，t的列名；结果列名形如 `值字段@列分类值` |
| `vals` | string \| array | 字符串或一维字符串数组，值字段，t的列名，多个字段可以用数组 |
返回：array
### 示例
```tsl
// 行标为日期、列标为名称，值为收盘价和涨幅的数据透视表
t := array(
("日期":"2021-05-17","名称":"平安银行","收盘价":22.5,"涨幅":1.2),
("日期":"2021-05-17","名称":"万科A","收盘价":30.1,"涨幅":-0.8),
("日期":"2021-05-18","名称":"平安银行","收盘价":22.9,"涨幅":1.8),
("日期":"2021-05-18","名称":"万科A","收盘价":29.7,"涨幅":-1.3));
return pivot(t, "日期", "名称", array("收盘价", "涨幅"));
// 输出：
// array("2021-05-17":
// ("收盘价@万科A":30.1,"收盘价@平安银行":22.5,"涨幅@万科A":-0.8,"涨幅@平安银行":1.2),"2021-05-18":
// ("收盘价@万科A":29.7,"收盘价@平安银行":22.9,"涨幅@万科A":-1.3,"涨幅@平安银行":1.8))
```
## `Pivot_table(t, index, columns, vals, aggfunc, aggfuncnames)`
声明：function
分组、透视、汇总 1、vals 未指定时，代表对所有除index、columns 指定字段之外的所有字段计算 2、aggfunc 不同含义及设定方法： a、所有字段，统一函数 aggfunc := "avg" 注：代表对vals中所有字段进行计算 b、所有字段，多个函数 aggfunc := array("avg","max"); c、指定字段，指定函数 aggfunc := array("fielda":"avg","filedb":("avg","max")); 注：指定字段时，必须是vals的子集，否则报错。 3、支持匿名函数、与函数指针，其中: a、匿名函数默认命名为"匿名" b、函数指针通过functioninfo得到函数名称 4、aggfunc中支持 a、所有 TS_SQL 聚合函数：e.g:"avg"(avgof),"sum"(sumof) b、内置函数： "\_details": 分组详情 "\_first": 第一个 "\_last": 最后一个 c、自定义函数中使用关键字thisgroup 得到当前分组数据。 5、index/columns中字段值含有nill等不可设为索引。 6、aggfuncnames：给aggfunc定义名称。
| 参数 | 类型 | 说明 |
| -------------- | ----------------------- | ------------------------ |
| `t` | array | 数据表 |
| `index` | string\|array | 行分类字段 |
| `columns` | string\|array | 列分类字段 |
| `vals` | string\|array | 值字段 |
| `aggfunc` | string\|array\|function | 汇总函数 |
| `aggfuncnames` | array | 自定义汇总函数名称对照表 |
返回：array
### 示例
```tsl
data := array(
("group": "A", "date": "2025-01-01", "value": 1),
("group": "A", "date": "2025-01-02", "value": 2),
("group": "B", "date": "2025-01-01", "value": 3)
);
echo trim(toStn(Pivot_table(
data,
"group",
"date",
"value",
"sum",
nil
)));
```
## `QKsplit_Resampling(begt, endt, cy, if_name)`
声明：function
区间自然日按指定周期重采样分割
| 参数 | 类型 | 说明 |
| --------- | -------- | ---------------------------------------------------------------------------- |
| `begt` | datetime | 日期时间，开始日 |
| `endt` | datetime | 日期时间，截止日 |
| `cy` | string | 字符串，采样周期，默认为cy_Day()，可以取日线、周线、月线、季线、半年线、年线 |
| `if_name` | string | object |
返回：array
### 示例
```tsl
echo trim(toStn(QKsplit_Resampling(20100101T, 20110101T, cy_year(), "")));
```
## `QKsplit_ToDate(endt, _type)`
声明：function
当前周期分割区间
| 参数 | 类型 | 说明 |
| ------- | -------- | ----------------------------------------------------------------------- |
| `endt` | datetime | 日期时间，截止日 |
| `_type` | any | 整型，为以下数值的组合(以下数值的\_XOR或者相加)，默认值为31(1+2+4+8+16) |
返回：array
### 示例
```tsl
echo trim(toStn(QKsplit_ToDate(20220704T, 31)));
```
## `QKsplit_Trailing(begt, endt, inc_weeks, inc_months, inc_years, other_type)`
声明：function
时间区间尾随分割
| 参数 | 类型 | 说明 |
| ------------ | -------- | ------------------------------------------------------ |
| `begt` | datetime | 日期时间，开始日 |
| `endt` | datetime | 日期时间，截止日 |
| `inc_weeks` | any | 数字/数组，周推移，取值如下 |
| `inc_months` | any | 数字/数组，月推移，同inc_weeks |
| `inc_years` | any | 数字/数组，年推移，同inc_weeks |
| `other_type` | any | 整型，为以下数值的组合(以下数值的\_XOR或者相加)，默认2 |
返回：array
### 示例
```tsl
echo trim(toStn(QKsplit_Trailing(20100101T, 20110101T, nil, nil, nil, 2)));
```
## `quickIntersectionPart(v, w)`
声明：function
快速求交集
| 参数 | 类型 | 说明 |
| ---- | ----- | ---- |
| `v` | array | 数组 |
| `w` | array | 数组 |
返回：array
### 示例
```tsl
t1 := array(1.00, 3.00, 2.00, 9.00, 8.00);
t2 := array(3.00, 0.00, 7.00, 8.00, 1.00, 5.00);
return intersectionPart(t1, t2);
```
## `quickRecordExist(v, x)`
声明：function
记录是否存在(原数组若为纯字符串数组则必须为有序列)，返回记录所在行的序号，序号是从0开始原数组必须为有序表
| 参数 | 类型 | 说明 |
| ---- | ------ | ----------- |
| `v` | array | 一维数组 |
| `x` | string | 字符串/数字 |
返回：integer
### 示例
```tsl
t := array('a', 'c', 'd');
return quickRecordExist(t, 'd');
// 结果：2
```
## `randomchoice(avalues, size, replace)`
声明：function
随机抽样
| 参数 | 类型 | 说明 |
| --------- | --------------- | ---------------------------------------- |
| `avalues` | array of string | Array of string,一维字符串数组，或正整数 |
| `size` | integer | Integer, |
| `replace` | bool | Bool,是否可放回,默认为真可放回 |
返回：any
### 示例
```tsl
// 从字符串数组中有放回随机抽取 3 个
return randomchoice(array("A", "B", "C", "D", "E"), 3, true);
// 输出：长度为 3 的随机子集，如 array("B","A","C")；因随机抽样每次运行结果不同。
// 若 avalues 传正整数 n，则从 0..n-1 中抽样，返回浮点下标数组。
```
## `rankIt(t, f_n, sort_order)`
声明：function
按指定字段的值排名；SortOrder：0 降序排名；SortOrder：1升序排名
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `t` | array | 数据表 |
| `f_n` | string | 字段名 |
| `sort_order` | integer | 排名方向，0 降序排名, 1升序排名 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
rankIt(t2, 'c', 1);
return t2;
// 输出：
// array(
// ("a":2,"c":13,"c排名":1),
// ("a":3,"c":33,"c排名":2))
```
## `rankIt2(t, f_n, of_n, sort_order)`
声明：function
按指定字段的值排名，SortOrder:0 降序排名；SortOrder:1 升序排名，排名列的字段为：OfN
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `t` | array | 数据表 |
| `f_n` | string | 指定字段，字符串 |
| `of_n` | string | 排名列字段名，字符串 |
| `sort_order` | integer | 排名方向:0 降序排名，1 升序排名 |
返回：array
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33));
rankIt2(t2, 'c', '名次', 1);
return t2;
// 输出：
// array(
// ("a":2,"c":13,"名次":1),
// ("a":3,"c":33,"名次":2))
```
## `rankValue(t, fields)`
声明：function
按照指定字段求Rank,返回的数据，保存在传递过来的数据t中。返回按Fields列排序的结果，
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `fields` | string | 字符串，排序的列 |
返回：any
### 示例
```tsl
// 对涨幅列进行排名，结果新增“涨幅(%)排名”列，并按排名升序重排
data := array(
("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.37),
("代码":"SH600016","名称":"民生银行","收盘":5.94,"涨幅(%)":-0.17),
("代码":"SH600028","名称":"中国石化","收盘":5.74,"涨幅(%)":0.17),
("代码":"SH600030","名称":"中信证券","收盘":18.58,"涨幅(%)":1.75),
("代码":"SH600036","名称":"招商银行","收盘":29.3,"涨幅(%)":0.31),
("代码":"SH600050","名称":"中国联通","收盘":5.36,"涨幅(%)":0.94));
rankValue(data, '涨幅(%)');
return data;
// 输出：
// array(
// ("代码":"SH600030","名称":"中信证券","收盘":18.58,"涨幅(%)":1.75,"涨幅(%)排名":1),
// ("代码":"SH600050","名称":"中国联通","收盘":5.36,"涨幅(%)":0.94,"涨幅(%)排名":2),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.37,"涨幅(%)排名":3),
// ("代码":"SH600036","名称":"招商银行","收盘":29.3,"涨幅(%)":0.31,"涨幅(%)排名":4),
// ("代码":"SH600028","名称":"中国石化","收盘":5.74,"涨幅(%)":0.17,"涨幅(%)排名":5),
// ("代码":"SH600016","名称":"民生银行","收盘":5.94,"涨幅(%)":-0.17,"涨幅(%)排名":6))
```
## `rDateStrToArr(rdate_list)`
声明：function
把报告期字符串转换为列表
| 参数 | 类型 | 说明 |
| ------------ | ------ | ------------------------------------------ |
| `rdate_list` | string | 字符串，报告期字符串，多个报告期以分号区分 |
返回：array
### 示例
```tsl
return rDateStrToArr('20070331;20070630');
```
## `readFile(filename, arg2, arg3, arg4, size, data)`
声明：function
文件访问函数相关函数。
| 参数 | 类型 | 说明 |
| ---------- | ------ | ---- |
| `filename` | int | |
| `arg2` | string | |
| `arg3` | int | |
| `arg4` | int | |
| `size` | string | |
| `data` | int | |
返回：bool
## `recodeSecond(a_value, a_second)`
声明：function
将参数ASecond指定的秒数（0至59）替换掉参数AValue中的相应的秒数信息，得到的日期时间类型返回
| 参数 | 类型 | 说明 |
| ---------- | -------- | --------------------------- |
| `a_value` | datetime | 日期时间类型 |
| `a_second` | int | 整数，秒数，定义域\[0，59\] |
返回：datetime
## `recordExist(t, v)`
声明：function
数值是否在数组中存在（一维数组），如果存在，则返回索引号；(索引号从0开始)不存在，返回－1
| 参数 | 类型 | 说明 |
| ---- | ------ | ------------------------------- |
| `t` | array | 指定一维数组 |
| `v` | string | 要查询的数值，与t单元值类型一致 |
返回：integer
### 示例
```tsl
t := array(1, 2, 12, 3, 14);
return recordExist(t, 12);
// 结果：2
```
## `recordExist2(t, f_name, v)`
声明：function
记录数据表（二维数组）中是否存在列名为fName，值为V的记录；如果存在，则返回行标索引号(索引号从0开始)，不存在，返回－1
| 参数 | 类型 | 说明 |
| -------- | ------ | ------------------------- |
| `t` | array | 指定数组，二维数组 |
| `f_name` | string | 指定列名，字符串 |
| `v` | string | 指定值，与t单元值类型一致 |
返回：integer
### 示例
```tsl
t1 := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 3));
return recordExist2(t1, 'b', 3);
// 结果：2
```
## `recordExist3(v, x)`
声明：function
记录指定值是否存在一维数组中，如果存在，返回1，不存在，返回0
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------- |
| `v` | string | 指定数组，一维数组 |
| `x` | integer | 指定值，与v单元值类型一致 |
返回：bool
### 示例
```tsl
t := array(1, 2, 12, 3, 14);
return recordExist3(t, 3);
// 结果：1
```
## `reIndex(data, index_info1, index_info2, index_info_n)`
声明：function
修改数组下标
| 参数 | 类型 | 说明 |
| -------------- | ----- | -------------- |
| `data` | array | 需要重构的数组 |
| `index_info1` | any | Array |
| `index_info2` | any | Array |
| `index_info_n` | any | Array |
返回：array
## `renameField(t, old_field, new_field)`
声明：function
修改指定字段的名称
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------------------- |
| `t` | array | 指定数组，数据表 |
| `old_field` | string | 原来指定列名，字符串 |
| `new_field` | string | 新列名，字符串 |
返回：bool
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return renameField(t1, 'a', 'aaa'); // 将t1中的字段’a’改为’aaa’
// 结果：1
```
## `renameFieldByFormat(t, ifcopy)`
声明：function
通过格式字符串修改列名。
| 参数 | 类型 | 说明 |
| -------- | ----- | -------------------------------------------- |
| `t` | array | 数组类型，数据 |
| `ifcopy` | bool | 布尔类型，是否在拷贝后的数组改列名，默认True |
返回：array
### 示例
```tsl
// 给随机数组批量加后缀
t := rand(10, 10);
suffix := '%s'$"@A";
ifcopy := true;
return renameFieldByFormat(t, suffix, ifcopy);
// 输出：把 10 列随机表的列名 0,1,…,9 按格式 '%s'$"@A" 批量改为 0@A,1@A,…,9@A。
// 列名重命名固定，但因 t 由 rand 生成，各单元格数值每次运行都不同。
```
## `replaceStrByReg(s, reg_from_text, to_text)`
声明：function
正则表达式快速字符串替换，大小写敏感。
| 参数 | 类型 | 说明 |
| --------------- | ------ | -------------------------------- |
| `s` | string | 字符串。源串 |
| `reg_from_text` | string | 字符串。待替换的部分，正则表达式 |
| `to_text` | string | 字符串。替换的字符串 |
返回：string
### 示例
```tsl
return replaceStrByReg("abcdeak", "A", "kkkk");
// 结果：abcdeak
```
## `replaceTextByReg(s, reg_from_text, to_text)`
声明：function
正则表达式快速字符串替换，大小写不敏感。
| 参数 | 类型 | 说明 |
| --------------- | ------ | -------------------------------- |
| `s` | string | 字符串。源串 |
| `reg_from_text` | string | 字符串。待替换的部分，正则表达式 |
| `to_text` | string | 字符串。替换的字符串 |
返回：string
### 示例
```tsl
return replaceTextByReg("abcdeak", "a", "kkkk");
// 结果：kkkkbcdekkkkk
```
## `reverse(arr)`
声明：function
数组倒置反向。
| 参数 | 类型 | 说明 |
| ----- | ----- | ---- |
| `arr` | array | 数组 |
返回：array
### 示例
```tsl
arr := array(
("date":"2021-05-26","close":1),
("date":"2021-05-27","close":2),
("date":"2021-05-28","close":3),
("date":"2021-05-31","close":4),
("date":"2021-06-01","close":5));
return reverse(arr);
// 输出：
// array(
// ("date":"2021-06-01","close":5),
// ("date":"2021-05-31","close":4),
// ("date":"2021-05-28","close":3),
// ("date":"2021-05-27","close":2),
// ("date":"2021-05-26","close":1))
```
## `rightStr(text, num_chars)`
声明：function
前N个字符；基于所指定的字符数返回文本字符串中的最后一个或后几个字符；
| 参数 | 类型 | 说明 |
| ----------- | ------ | -------- |
| `text` | string | 字符串 |
| `num_chars` | int | 字符个数 |
返回：string
## `rotateTable(data)`
声明：function
旋转表
| 参数 | 类型 | 说明 |
| ------ | ----- | ---------------- |
| `data` | array | 数据表，二维数组 |
返回：array
### 示例
```tsl
t := array(('a': 1, 'b': 4), ('a': 7, 'b': 8), ('a': 2, 'b': 4));
return rotateTable(t);
```
## `roundTo5(v)`
声明：function
.5处理
| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `v` | real | 实数 |
返回：real
### 示例
```tsl
return roundTo5(0.35);
// 结果：0.5
```
## `rpsIt(t, f_n, sort_order)`
声明：function
按指定字段的值排名，获得其排名的百分位，排序百分位放在列 FN+"\_RPS"中；
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------- |
| `t` | array | 数组，数据表 |
| `f_n` | string | 字符串/数字，字段名 |
| `sort_order` | integer | 排名方向，0 降序排名, 1升序排名 |
返回：array
### 示例
```tsl
r := array(
("StockID":"SZ000001","StockName":"平安银行","StockZF":0.28),
("StockID":"SZ000002","StockName":"万 科Ａ","StockZF":-0.12),
("StockID":"SH600997","StockName":"开滦股份","StockZF":0.66),
("StockID":"SZ000009","StockName":"中国宝安","StockZF":2.47),
("StockID":"SZ000012","StockName":"南 玻Ａ","StockZF":1.27),
("StockID":"SZ000024","StockName":"招商地产","StockZF":0.05));
return rpsIt(r, 'StockZF', 1);
// 输出：
// array(
// ("StockID":"SZ000009","StockName":"中国宝安","StockZF":2.47,"StockZF_RPS":100.0),
// ("StockID":"SZ000012","StockName":"南 玻Ａ","StockZF":1.27,"StockZF_RPS":80.0),
// ("StockID":"SH600997","StockName":"开滦股份","StockZF":0.66,"StockZF_RPS":60.0),
// ("StockID":"SZ000001","StockName":"平安银行","StockZF":0.28,"StockZF_RPS":40.0),
// ("StockID":"SZ000024","StockName":"招商地产","StockZF":0.05,"StockZF_RPS":20.0),
// ("StockID":"SZ000002","StockName":"万 科Ａ","StockZF":-0.12,"StockZF_RPS":0.0))
```
## `rpsValue(t, column_name)`
声明：function
按照指定字段求RPS。
| 参数 | 类型 | 说明 |
| ------------- | ------ | ----------------------- |
| `t` | array | 数据表类型，数据表 |
| `column_name` | string | 字符串，要计算RPS的字段 |
返回：any
### 示例
```tsl
s := array(
("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892),
("代码":"SZ000002","名称":"万 科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225),
("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115),
("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175));
rpsValue(s, '涨幅(%)');
return s;
// 返回:
// array(
// ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175,"RPS_涨幅(%)":100.0),
// ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892,"RPS_涨幅(%)":66.6666666666667),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115,"RPS_涨幅(%)":33.3333333333333),
// ("代码":"SZ000002","名称":"万 科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225,"RPS_涨幅(%)":0.0))
```
## `searchsorted(v, x)`
声明：function
有序列表插入指定值的位置，原数组必须为有序表且元素应可比较。
| 参数 | 类型 | 说明 |
| ---- | -------------- | ----------------- |
| `v` | array | 一维数组 有序数组 |
| `x` | string \| real | 插入的值 |
返回：integer
### 示例
范例1：数字插入
```tsl
v := array(1, 2, 3, 4, 5, 6);
return searchsorted(v, 3.5); // 返回：3
```
范例2：字符串插入
```tsl
v := array("SH600001", "SH600004", "SH600050", "SH600305");
return searchsorted(v, "SH600049"); // 返回：2
```
## `seekPosInArray(r, arr)`
声明：function
数字定位，采用二分法寻找数字R在一位正序数字数组arr中的下标。
| 参数 | 类型 | 说明 |
| ----- | ----- | ------------ |
| `r` | real | 实数 |
| `arr` | array | 一维数字数组 |
返回：integer
### 示例
```tsl
return seekPosInArray(4, array(1, 2, 3, 4, 5));
// 返回：3
```
## `seperateTable(t, sep_field, sep_count)`
声明：function
把表格t分割为SepCount个表格。
| 参数 | 类型 | 说明 |
| ----------- | ------- | -------------------- |
| `t` | array | 数据表类型，原始数组 |
| `sep_field` | string | 字符串，排序字段 |
| `sep_count` | integer | 整数，分割数 |
返回：array
### 示例
```tsl
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return seperateTable(t, 'a', 2);
// 返回:
// array(
// (
// ("a":4,"b":5,"c":6,"d":7,"e":8,"f":10),
// ("a":3,"b":4,"c":5,"d":6,"e":7,"f":9)),
// (
// ("a":2,"b":3,"c":4,"d":5,"e":6,"f":8),
// ("a":1,"b":2,"c":3,"d":4,"e":5,"f":7)))
```
## `seprateStrToTotal(s)`
声明：function
把用;分割的字符串转换为#分割
| 参数 | 类型 | 说明 |
| ---- | ------ | ------ |
| `s` | string | 字符串 |
返回：string
### 示例
```tsl
return seprateStrToTotal('债券型;现金型;配置型;股票型;保本型');
// 结果：’债券型#现金型#配置型#股票型#保本型’
```
## `setLikeFlag(flag, return_value)`
声明：function
设置Like操作符号的正则表达式默认控制状态。默认值为1。
| 参数 | 类型 | 说明 |
| -------------- | ---- | ------------------------------------------------------------------------------------- |
| `flag` | int | 正则表达式控制模式，取值如下： 若同时设置多个模式，则设置参数值为其对应模式值之和即可 |
| `return_value` | int | 匹配成功则返回真，否则返回假 |
返回：bool
## `setRowDefaultValue(t, n, value)`
声明：function
将数组t的第N行由所有值变更为Value。
| 参数 | 类型 | 说明 |
| ------- | ------- | ------------------ |
| `t` | array | 数据表类型，数据表 |
| `n` | integer | 整数，行号 |
| `value` | string | 字符串，要设置的值 |
返回：array
### 示例
```tsl
s := array(array(1, 2, 3, 4, 5),
array(2, 3, 4, 5, 6),
array(3, 4, 5, 6));
setRowDefaultValue(s, 2, 'wo');
return s;
// 返回:
```
## `sf_Beta(arg1, arg2, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any | |
| `arg2` | any | |
| `v` | any | |
返回：any
## `sf_betainv(y, arg2, arg3, x)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `y` | array | |
| `arg2` | any | |
| `arg3` | any | |
| `x` | any | |
返回：any
## `sf_CosX(arg1, v)`
声明：function
数值计算相关函数。
| 参数 | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any | |
| `v` | any | |
返回：any
## `sf_Error(arg1, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `v` | any | |
返回：any
## `sf_eX(arg1, v)`
声明：function
数值计算相关函数。
| 参数 | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any | |
| `v` | any | |
返回：any
## `sf_finv(arg1, arg2, arg3, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `arg2` | any | |
| `arg3` | any | |
| `v` | any | |
返回：any
## `sf_Gamma(arg1, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any | |
| `v` | any | |
返回：any
## `sf_gammainv(arg1, arg2, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `arg2` | any | |
| `v` | any | |
返回：any
## `sf_Normal(x, a, d, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x` | any | |
| `a` | any | |
| `d` | any | |
| `v` | any | |
返回：any
## `sf_normalinv(arg1, arg2, arg3, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `arg2` | any | |
| `arg3` | any | |
| `v` | any | |
返回：any
## `sf_normalinv2(arg1, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `v` | any | |
返回：any
## `sf_SinX(arg1, v)`
声明：function
数值微积分相关函数。
| 参数 | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any | |
| `v` | any | |
返回：float
## `sf_tinv(arg1, arg2, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `arg2` | any | |
| `v` | any | |
返回：any
## `sf_x2inv(arg1, arg2, v)`
声明：function
统计分布相关函数。
| 参数 | 类型 | 说明 |
| ------ | ----- | ---- |
| `arg1` | float | |
| `arg2` | any | |
| `v` | any | |
返回：any
## `show2DTable(t, key_field, obsolete_fields, ntype)`
声明：function
特殊函数，平台功能性函数，一般用户不使用。二位表格显示格式转换，其中t为原数据,KeyField为需要转置的字段，ObsoleteFields为需要隐藏的字段，NType决定显示格式。
| 参数 | 类型 | 说明 |
| ----------------- | ------- | ---------------------------- |
| `t` | array | 数据表类型，原数据 |
| `key_field` | string | 字符串，要显示倒置的关键字段 |
| `obsolete_fields` | string | 字符串，不显示的字段(;分割) |
| `ntype` | integer | 用户自定义，二维表格显示格式 |
返回：array
### 示例
```tsl
// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "主营业务收入": 151953.06, "主营业务利润": 30559.66, "营业费用": 10112.75, "管理费用": 10666.36, "财务费用": -894.46, "营业利润": 10693.23, "投资收益": -151.01, "利润总额": 9904.7, "所得税": 2413.81, "净利润": 7873.08, "货币资金": -11664.28, "短期投资": -5370.7, "主营业务收入": 167855.56, "主营业务利润": 31127.95, "营业费用": 4452.79, "管理费用": 10541.15, "财务费用": -1013.26, "营业利润": 17162.48, "投资收益": 150.81, "利润总额": 17246.26, "所得税": 2629.5, "净利润": 14574.03, "货币资金": 532.5, "短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "主营业务收入": 19715.3, "主营业务利润": 10383.2, "营业费用": 238.4, "管理费用": 1422.7, "财务费用": 1304.4, "营业利润": 7417.7, "投资收益": 81.1, "利润总额": 6404.6, "所得税": 2433.4, "净利润": 3971.2, "货币资金": 2964.5, "短期投资": 0.00, "主营业务收入": 17727.7, "主营业务利润": 9989.1, "营业费用": 165.5, "管理费用": 1151.3, "财务费用": -18.2, "营业利润": 8690.5, "投资收益": 186.2, "利润总额": 9208.6, "所得税": 2977.1, "净利润": 6231.5, "货币资金": -8101.2, "短期投资": 0.00));
return show2DTable(t, '名称', '代码', 2);
// 返回:
```
## `show3DTable(t, key_field, obsolete_fields, ntype)`
声明：function
特殊函数，平台功能性函数，一般用户不使用。用于三维表格显示格式转换，其中t为原数据,KeyField为需要转置的字段，ObsoleteFields为需要隐藏的字段，NType决定显示格式。
| 参数 | 类型 | 说明 |
| ----------------- | ------- | ---------------------------- |
| `t` | array | 数据表类型，原数据 |
| `key_field` | string | 字符串，要显示倒置的关键字段 |
| `obsolete_fields` | string | 字符串，不显示的字段(;分割) |
| `ntype` | integer | 用户自定义，三维表格显示格式 |
返回：array
### 示例
```tsl
// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "2004.10-12@主营业务收入": 151953.06, "2004.10-12@主营业务利润": 30559.66, "2004.10-12@营业费用": 10112.75, "2004.10-12@管理费用": 10666.36, "2004.10-12@财务费用": -894.46, "2004.10-12@营业利润": 10693.23, "2004.10-12@投资收益": -151.01, "2004.10-12@利润总额": 9904.7, "2004.10-12@所得税": 2413.81, "2004.10-12@净利润": 7873.08, "2004.10-12@货币资金": -11664.28, "2004.10-12@短期投资": -5370.7, "2004.7-9@主营业务收入": 167855.56, "2004.7-9@主营业务利润": 31127.95, "2004.7-9@营业费用": 4452.79, "2004.7-9@管理费用": 10541.15, "2004.7-9@财务费用": -1013.26, "2004.7-9@营业利润": 17162.48, "2004.7-9@投资收益": 150.81, "2004.7-9@利润总额": 17246.26, "2004.7-9@所得税": 2629.5, "2004.7-9@净利润": 14574.03, "2004.7-9@货币资金": 532.5, "2004.7-9@短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "2004.10-12@主营业务收入": 19715.3, "2004.10-12@主营业务利润": 10383.2, "2004.10-12@营业费用": 238.4, "2004.10-12@管理费用": 1422.7, "2004.10-12@财务费用": 1304.4, "2004.10-12@营业利润": 7417.7, "2004.10-12@投资收益": 81.1, "2004.10-12@利润总额": 6404.6, "2004.10-12@所得税": 2433.4, "2004.10-12@净利润": 3971.2, "2004.10-12@货币资金": 2964.5, "2004.10-12@短期投资": 0.00, "2004.7-9@主营业务收入": 17727.7, "2004.7-9@主营业务利润": 9989.1, "2004.7-9@营业费用": 165.5, "2004.7-9@管理费用": 1151.3, "2004.7-9@财务费用": -18.2, "2004.7-9@营业利润": 8690.5, "2004.7-9@投资收益": 186.2, "2004.7-9@利润总额": 9208.6, "2004.7-9@所得税": 2977.1, "2004.7-9@净利润": 6231.5, "2004.7-9@货币资金": -8101.2, "2004.7-9@短期投资": 0.00), ("代码": "SH600004", "名称": "白云机场", "2004.7-9@主营业务收入": 37934.65, "2004.7-9@主营业务利润": 15725.54, "2004.7-9@营业费用": 2623.82, "2004.7-9@管理费用": 4662.1, "2004.7-9@财务费用": 1789.5, "2004.7-9@营业利润": 6650.11, "2004.7-9@投资收益": -15.38, "2004.7-9@利润总额": 6685.16, "2004.7-9@所得税": 2350.15, "2004.7-9@净利润": 4000.51, "2004.7-9@货币资金": -5054.06, "2004.7-9@短期投资": 101.00));
return show3DTable(t, '名称', '代码', 3);
// 返回:
```
## `showTableByField(t, field_arr)`
声明：function
显示数据表t的部分字段数据，字段在FieldArr的数组里。
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------------- |
| `t` | array | 数据表类型，数据 |
| `field_arr` | array | 一维数组，要显示的字段 |
返回：array
### 示例
```tsl
arr := array((1, 2, 3, 4, 5), (2, 3, 4, 5, 6), (3, 4, 5, 6, 7), (4, 5, 6, 7, 8));
return showTableByField(arr, array(1, 2, 3));
// 返回:
```
## `showTableByInverse(t, key_field, field_arr, show_number)`
声明：function
数据表t转置，其中KeyField为列名，该列的数据转置后作为列标名，FieldARR为需要显示的字段，ShowNumber表示显示原数据keyfield行(转置后列)的数量。
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------------------------------------------ |
| `t` | array | 数据表类型，数据 |
| `key_field` | string | 字符串，转置后用作列标的值的列名 |
| `field_arr` | array | 数组，要显示的字段列表，给非数组则显示所有字段。 |
| `show_number` | integer | 整数，显示个数 |
返回：array
### 示例
```tsl
// 生成数据表t
t := array(("代码": "SH600006", "名称": "东风汽车", "主营业务收入": 151953.06, "主营业务利润": 30559.66, "营业费用": 10112.75, "管理费用": 10666.36, "财务费用": -894.46, "营业利润": 10693.23, "投资收益": -151.01, "利润总额": 9904.7, "所得税": 2413.81, "净利润": 7873.08, "货币资金": -11664.28, "短期投资": -5370.7, "主营业务收入": 167855.56, "主营业务利润": 31127.95, "营业费用": 4452.79, "管理费用": 10541.15, "财务费用": -1013.26, "营业利润": 17162.48, "投资收益": 150.81, "利润总额": 17246.26, "所得税": 2629.5, "净利润": 14574.03, "货币资金": 532.5, "短期投资": 4962.47), ("代码": "SH600007", "名称": "中国国贸", "主营业务收入": 19715.3, "主营业务利润": 10383.2, "营业费用": 238.4, "管理费用": 1422.7, "财务费用": 1304.4, "营业利润": 7417.7, "投资收益": 81.1, "利润总额": 6404.6, "所得税": 2433.4, "净利润": 3971.2, "货币资金": 2964.5, "短期投资": 0.00, "主营业务收入": 17727.7, "主营业务利润": 9989.1, "营业费用": 165.5, "管理费用": 1151.3, "财务费用": -18.2, "营业利润": 8690.5, "投资收益": 186.2, "利润总额": 9208.6, "所得税": 2977.1, "净利润": 6231.5, "货币资金": -8101.2, "短期投资": 0.00));
return showTableByInverse(t, '代码', '', 2);
// 返回:
```
## `ShowTableByUnit(t, field_arr)`
声明：function
显示t部分字段(带显示单位变换)。其中FieldArr为二维数组，FieldArr的第0列为显示的字段名称，第1列为显示的字段对应的数据列名称，第2列为显示的字段的数据类型，第3列为显示的字段的单位(只对Real类型有意义)。
| 参数 | 类型 | 说明 |
| ----------- | ----- | ---------------------------- |
| `t` | array | 数据表类型，要显示的数据 |
| `field_arr` | array | 二位字符串数组，要显示的字段 |
返回：Array，数组。
### 示例
```tsl
data := array("a": (1, 2), "b": (3, 4));
fields := array(("field_a", "a", "", ""));
echo trim(toStn(ShowTableByUnit(data, fields)));
```
## `simpledescribe(data)`
声明：function
简单描述统计
| 参数 | 类型 | 说明 |
| ------ | --------------- | ----------------------------------------------------- |
| `data` | array of number | 一维数字数组，或 二维矩阵，二维矩阵时，对每列进行操作 |
返回：array
### 示例
```tsl
data := array(
("H": 10, "W": 2, "L": 4),
("H": 20, "W": 4, "L": 8),
("H": 30, "W": 6, "L": 12));
return simpledescribe(data);
// 输出：
// array("个数":
// ("H":3,"W":3,"L":3),"最小值":
// ("H":10.0,"W":2.0,"L":4.0),"25%":
// ("H":15.0,"W":3.0,"L":6.0),"50%":
// ("H":20.0,"W":4.0,"L":8.0),"75%":
// ("H":25.0,"W":5.0,"L":10.0),"最大值":
// ("H":30.0,"W":6.0,"L":12.0),"平均值":
// ("H":20.0,"W":4.0,"L":8.0),"标准差":
// ("H":10.0,"W":2.0,"L":4.0))
```
## `simpleRoundTo2(avalue, adigit)`
声明：function
四舍五入（交易所规则），正负数不对称，即四舍六入，五向较大的数进位(正负有别,如保留一位小数时+0.05)
| 参数 | 类型 | 说明 |
| -------- | ------- | -------------- |
| `avalue` | Real | 实数数据 |
| `adigit` | Integer | 精确到Adigit位 |
返回：Real
### 示例
```tsl
范例01：
return simpleRoundTo2(1234.56789654,-2);
//结果：1234.57
范例02：
return simpleRoundTo2(-1234.5658965,-2);
//结果：-1234.56
```
## `skewByColumn(t, f_name)`
声明：function
指定列的偏度
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return skewByColumn(t2, 'c');
// 结果：-0.75
```
## `sortTableByFieldExt(t, sort_field)`
声明：function
将数组t依据字段SortField排序。把大于0的按照从小到大排序，把小于0的按照绝对值从小到大排序，然后，把两个结果合并。
| 参数 | 类型 | 说明 |
| ------------ | ------ | ---------------- |
| `t` | array | 数据表类型，数组 |
| `sort_field` | string | 字符串,排序字段 |
返回：any
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return sortTableByFieldExt(s, 'b');
// 返回:
```
## `spaceByNumber(n)`
声明：function
生成N个空格字符串
| 参数 | 类型 | 说明 |
| ---- | ------- | ---- |
| `n` | integer | 整数 |
返回：string
### 示例
```tsl
return write('---', spaceByNumber(2), '---');
// 运行信息打印结果：
```
## `sparse1(s, a, m, n)`
声明：function
挤出任何非零元素，将满矩阵转化为稀疏格式，与Sparsefull函数对应。
| 参数 | 类型 | 说明 |
| ---- | ------------- | --------------------------------- |
| `s` | array of real | 待转化的m\*n满矩阵 |
| `a` | array of real | 变参返回矩阵S的稀疏格式，二维数组 |
| `m` | integer | 变参返回矩阵S的行数，整数 |
| `n` | integer | 变参返回矩阵S的列数，整数 |
返回：array
### 示例
```tsl
// 将矩阵S由满矩阵格式转化为稀疏格式
s := array((0, 0, 4, 0, 0),
(0, 1, 0, 0, 0),
(0, 0, 0, 0, 0),
(3, 0, 0, 0, 0),
(0, 0, 0, 0, 5));
return sparse1(s);
// 输出：
// array(0:
// (2:4),1:
// (1:1),3:
// (3),4:
// (4:5))
```
## `sparse2(i, j, v, m, n)`
声明：function
根据i、j和v三元组生成m\*n稀疏格式矩阵S
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------ |
| `i` | array of real | 存放矩阵行标的一元数组 |
| `j` | array of real | 存放矩阵列标的一元数组 |
| `v` | array of real | 存放矩阵元素值的一元数组 |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
返回：array
### 示例
```tsl
// 根据i,j,v三元组生成稀疏格式矩阵
i := array(0, 1, 2, 3);
j := array(3, 1, 4, 2);
v := array(5, 3, 2, 4);
return sparse2(i, j, v, 5, 5);
// 输出：
// array(
// (3:5),
// (1:3),
// (4:2),
// (2:4))
```
## `sparsefull(s, m, n)`
声明：function
将稀疏矩阵格式转化为满矩阵，与Sparse1函数相对应。
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------ |
| `s` | array of real | 稀疏格式矩阵 |
| `m` | integer | 转化为满矩阵的行数，整数 |
| `n` | integer | 转化为满矩阵的列数，整数 |
返回：array
### 示例
```tsl
// 将S由稀疏格式矩阵转化为5*5满矩阵格式
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return sparsefull(s, 5, 5);
// 输出：
// array(
// (1,0,0,0,0),
// (0,0,0,0,0),
// (0,0,3,0,0),
// (0,0,0,4,0),
// (0,0,0,0,0))
```
## `sparseMatFill(a, fillv)`
声明：function
稀疏数据表填充，直接在A矩阵上更改
| 参数 | 类型 | 说明 |
| ------- | ---------------- | -------------------- |
| `a` | array,tablearray | 数据表类型，稀疏矩阵 |
| `fillv` | real | 实数，给定的填充值 |
返回：array,tablearray
### 示例
```tsl
a := array((3: 4), ('A': 2));
sparseMatFill(a, -1);
return a; // array((3:4,"A":-1),(3:-1,"A":2))
```
## `spdiags1(a)`
声明：function
提取矩阵非零对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
返回：array
### 示例
```tsl
// 提取矩阵A中非零对角线
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags1(a);
```
## `spdiags2(a, d)`
声明：function
提取矩阵指定对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------------------ |
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
| `d` | array | Array,一维数组，对角线序列；也可以为数字； |
返回：array
### 示例
```tsl
// 提取矩阵A中第-2,0,2条对角线，按列排列
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
d := array(-2, 0, 2);
return spdiags2(a, d);
```
## `spdiags3(b, d, a)`
声明：function
根据指定列替换稀疏矩阵对角线
| 参数 | 类型 | 说明 |
| ---- | ----- | ------------------------------ |
| `b` | array | Array,二维数组，对角矩阵 |
| `d` | array | Array,一维数组，对角线序列 |
| `a` | array | Array,二维数组，原（稀疏）矩阵 |
返回：array
### 示例
```tsl
// 将矩阵A中d指定的对角线替换为B中的列
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
a := array((6, 0, 13, 0, 0),
(0, 7, 0, 14, 0),
(1, 0, 8, 0, 15),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return spdiags3(b, d, a);
```
## `spdiags4(b, d, m, n)`
声明：function
根据指定列创建稀疏矩阵
| 参数 | 类型 | 说明 |
| ---- | ------- | -------------------------------- |
| `b` | array | Array,二维数组，对角矩阵 |
| `d` | array | Array,一维数组，对角线序列 |
| `m` | integer | Integer,正整数，（稀疏）矩阵的行 |
| `n` | integer | Integer,正整数，（稀疏）矩阵的列 |
返回：array
### 示例
```tsl
// 根据对角矩阵B创建稀疏带状矩阵
b := array((5, 10, 15),
(4, 9, 14),
(3, 8, 13),
(2, 7, 12),
(1, 6, 11));
d := array(-2, 0, 2);
m := 5;
n := 5;
return spdiags4(b, d, m, n);
```
## `speye(m)`
声明：function
创建m\*m稀疏单位矩阵，指定为方阵
| 参数 | 类型 | 说明 |
| ---- | ------- | ------------------------ |
| `m` | integer | 稀疏单位矩阵的尺寸，整数 |
返回：array
### 示例
```tsl
// 创建m*m稀疏单位矩阵
a := speye(4);
return a;
// 输出：
// array(
// (1),
// (1:1),
// (2:1),
// (3:1))
```
## `spnnz(s)`
声明：function
稀疏矩阵S中的非零元素数目
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：integer
### 示例
```tsl
// 稀疏正态随机矩阵A中非零元素数目
a := sprandn2(5, 5, 0.2);
return spnnz(a); // 返回4（随机）
```
## `spnonzeros(s)`
声明：function
提取稀疏矩阵S中的非零元素
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 提取稀疏正态随机矩阵A中非零元素
a := sprandn2(5, 5, 0.2);
return spnonzeros(a);
// 输出：一维数组，按顺序列出稀疏矩阵 a 中所有非零元素的值。
// 因 a 由 sprandn2 生成，非零元素个数与数值每次运行都不同。
```
## `spones(s, n)`
声明：function
将稀疏矩阵S中的非零元素替换为n
| 参数 | 类型 | 说明 |
| ---- | ------------- | ------------------------ |
| `s` | array of real | 稀疏矩阵 |
| `n` | real | 非零元素被替换的值，实数 |
返回：array
### 示例
```tsl
// 将S中非零元素替换为1
s := array(0: (0: 1), 2: (2: 3), 3: (3: 4));
return spones(s, 1);
// 输出：
// array(0:
// (1),2:
// (2:1),3:
// (3:1))
```
## `sprand1(s)`
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为均匀分布随机数
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 创建与矩阵S相同结构的稀疏均匀随机矩阵
s := array((0, 0, 3, 0, 0),
(0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(0, 2, 0, 0, 0),
(0, 0, 0, 0, 4));
return sprand1(s);
// 输出：与 S 结构相同(非零位置一致)的稀疏矩阵，非零元素替换为 (0,1) 均匀随机数。
// 非零位置固定，但随机值每次运行都不同。
```
## `sprand2(m, n, pct)`
声明：function
创建m\*n稀疏均匀随机矩阵，其中非零元素所占比例为pct
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
| `pct` | real | 矩阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10稀疏均匀随机矩阵
a := sprand2(10, 10, 0.3);
return a;
// 输出：10*10 稀疏矩阵，约 30% 位置非零，非零元素为 (0,1) 均匀随机数。
// 非零位置与数值每次运行都不同。
```
## `sprandn1(s)`
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，并将其中的非零元素替换为正态分布随机数
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 创建与矩阵S相同结构的稀疏正态随机矩阵
s := array((0, 0, 0, 0, 0),
(0, 0, 0, 5, 0),
(3, 0, 0, 0, 0),
(0, 0, 2, 0, 0),
(0, 0, 0, 0, 4));
return sprandn1(s);
// 输出：与 S 结构相同(非零位置一致)的稀疏矩阵，非零元素替换为标准正态随机数。
// 非零位置固定，但随机值每次运行都不同。
```
## `sprandn2(m, n, pct)`
声明：function
创建m\*n稀疏正态随机矩阵，其中非零元素所占比例为pct
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `m` | integer | 矩阵的行数，整数 |
| `n` | integer | 矩阵的列数，整数 |
| `pct` | real | 矩阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10稀疏正态随机矩阵
a := sprandn2(10, 10, 0.2);
return a;
// 输出：10*10 稀疏矩阵，约 20% 位置非零，非零元素为标准正态随机数。
// 非零位置与数值每次运行都不同。
```
## `sprandsym1(s)`
声明：function
创建与矩阵S结构相同的稀疏格式矩阵，以下三角矩阵为基准的对称正态分布随机矩阵
| 参数 | 类型 | 说明 |
| ---- | ------------- | -------- |
| `s` | array of real | 稀疏矩阵 |
返回：array
### 示例
```tsl
// 创建与矩阵S相同结构的对称稀疏正态随机矩阵
s := array((6, 1, 0, 14, 0),
(0, 7, 0, 0, 15),
(1, 0, 8, 0, 0),
(0, 2, 0, 9, 0),
(0, 0, 3, 0, 10));
return sprandsym1(s);
// 输出：与 S 相同结构的对称稀疏矩阵，非零元素为正态随机数且关于主对角线对称。
// 非零位置固定，但随机值每次运行都不同。
```
## `sprandsym2(n, pct)`
声明：function
创建n\*n稀疏正态随机矩阵，以下三角矩阵为基准对称正态分布随机矩阵，其中非零元素所占比例大约为pct
| 参数 | 类型 | 说明 |
| ----- | ------- | ---------------------------- |
| `n` | integer | 方阵的尺寸，整数 |
| `pct` | real | 方阵中非零元素所占比例，实数 |
返回：array
### 示例
```tsl
// 创建10*10对称稀疏正态随机矩阵
a := sprandsym2(10, 0.2);
return a;
// 输出：10*10 对称稀疏矩阵，约 20% 位置非零，以下三角为基准对称，非零元素为正态随机数。
// 非零位置与数值每次运行都不同。
```
## `startOfTheHalfYear(end_t)`
声明：function
返回Endt所在半年的开始日期（半年的第一天）
| 参数 | 类型 | 说明 |
| ------- | --------- | ---- |
| `end_t` | tdatetime | 日期 |
返回：tdatetime
### 示例
```tsl
end_t := 40599; // 40559表示2011年1月16号
return startOfTheHalfYear(end_t);
// 结果：40544 //40544表示2011年1月1号
```
## `startOfTheQuarter(end_t)`
声明：function
返回Endt所在季度的开始日期（季度的第一天）
| 参数 | 类型 | 说明 |
| ------- | --------- | ---- |
| `end_t` | tdatetime | 日期 |
返回：tdatetime
### 示例
```tsl
end_t := 40540; // 40540表示2010年12月28日
return startOfTheQuarter (end_t);
// 结果：40452 //40452表示2010年10月1号
```
## `statByColumn(t, fname, _type)`
声明：function
依据Type传递的字符串，返回字段Fname序列的type值。
| 参数 | 类型 | 说明 |
| ------- | ------ | ---------------- |
| `t` | array | 数据表类型，数据 |
| `fname` | string | 字符串，字段名称 |
| `_type` | string | 字符串，返回类型 |
返回：any
### 示例
```tsl
s := `array('a': (1, 2, 3, 4, 5), 'b': (-2, -3, -4, 5, 6), 'c': (3, 4, 5, 6, 7), 'd': (4, 5, 6, 7, 8));
return statByColumn(s, 'a', 'MAX');
// 返回a列最大值:5
```
## `stdevByColumn(t, f_name)`
声明：function
指定列的标准差
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return stdevByColumn(t2, 'c');
// 结果：17.08
```
## `stm(v)`
声明：function
把STM流转换为任意类型。
| 参数 | 类型 | 说明 |
| ---- | ------ | ----------------- |
| `v` | binary | 二进制类型，STM流 |
返回：any
## `stockAmount(t, date, yes_value, change_field, item)`
声明：function
在有序数据表 t 中，按 `change_field` 列定位最后一个不晚于 Date 的行（即 `change_field <= Date` 的最近一行），返回其 `item` 列的值；`yes_value` 决定取该行本身还是其前一行。
| 参数 | 类型 | 说明 |
| -------------- | ------- | ------------------------------------------------------------ |
| `t` | array | 数据表类型，按 `change_field` 升序排列的数据表 |
| `date` | integer | 实数或日期，用于与 `change_field` 列比较的基准值 |
| `yes_value` | integer | 布尔值。0：返回命中行（Date 当期）；非 0：返回命中行的前一行 |
| `change_field` | string | 与 Date 比较的列名 |
| `item` | string | 返回值所在的列名 |
返回：any。命中行（或其前一行）中 `item` 列的值；若表中不存在不晚于 Date 的行，返回 0。
### 示例
```tsl
t := array(
("变动日": 20110630, "收盘价": 90),
("变动日": 20120630, "收盘价": 60),
("变动日": 20130530, "收盘价": 33),
("变动日": 20110630, "收盘价": 90),
("变动日": 20130630, "收盘价": 30),
("变动日": 20140630, "收盘价": 20));
r1 := stockAmount(t, 20130630, 0, '变动日', '收盘价'); // Date当期
r2 := stockAmount(t, 20130630, 1, '变动日', '收盘价'); // 命中行的前一行
return array(r1, r2);
// 输出：array(30,90)
```
## `strSubscriptTableToNormal(t, fn)`
声明：function
字符串下标数组-->索引下标数组。
| 参数 | 类型 | 说明 |
| ---- | ------ | ---------------------------------------- |
| `t` | array | 二维数组，数据 |
| `fn` | string | 字符串或数值，行标变成数据之后使用的列名 |
返回：array
### 示例
```tsl
data := array("a": (1, 2), "b": (3, 4));
echo trim(toStn(strSubscriptTableToNormal(data, "source_index")));
```
## `strToDateExt(s, str_format)`
声明：function
将字符串类型的日期按照不同的格式转换成实数型的日期。
| 参数 | 类型 | 说明 |
| ------------ | ------- | ------------------------------------------ |
| `s` | string | 字符串类型的日期，包含3中形式，见下表。 |
| `str_format` | integer | 标准化的日期格式，对应的S分别用0、1、2表示 |
返回：tdatetime
### 示例
```tsl
s := '16/1/2011';
str_format := 0;
return strToDateExt(s, str_format);
// 结果：40559
```
## `strtodatetime2(s)`
声明：function
字符串->日期时间(包含毫秒)
| 参数 | 类型 | 说明 |
| ---- | ------ | -------------------------------------------------------------------------------------------------------------- |
| `s` | string | S的格式必须为：yyyy-m-d h:m:s:z    其中日期和时间需要用空格隔开，时间分隔必须用:    如"2021-8-12 10:31:24:199" |
返回：tdatetime
### 示例
```tsl
// 字符串2021-8-12 10:31:24:199 转换为日期时间格式(包含毫秒)
s := "2021-8-12 10:31:24:199";
return strtodatetime2(s); // 结果：44420.4384745255
```
## `sumValueByColumn(t, f_name)`
声明：function
指定列中所有实数的和
| 参数 | 类型 | 说明 |
| -------- | ------ | -------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定字段 |
返回：real
### 示例
```tsl
t1 := array(('a': 1, 'b': 4, 'c': 9), ('a': 7, 'b': 8, 'c': 5));
return sumValueByColumn(t1, 'b');
// 结果：12
```
## `sumValueByColumn2(tb, column_name, from_row, to_row)`
声明：function
求指定列中指定多行的和
| 参数 | 类型 | 说明 |
| ------------- | ------- | ------------------------------- |
| `tb` | array | 数据表 |
| `column_name` | string | 指定字段 |
| `from_row` | integer | 指定计算起始行索引号（从0开始） |
| `to_row` | integer | 指定计算结束行索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByColumn2(t2, 'c', 1, 2);
// 结果：76
```
## `sumValueByRow(tb, row_index)`
声明：function
求指定行的和
| 参数 | 类型 | 说明 |
| ----------- | ------- | --------------------------- |
| `tb` | array | 数据表 |
| `row_index` | integer | 指定计算行索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow(t2, 2);
// 结果：46
```
## `sumValueByRow2(tb, row_index, from_col, to_col)`
声明：function
求指定行中指定多列的和
| 参数 | 类型 | 说明 |
| ----------- | ------- | ------------------------------- |
| `tb` | array | 数据表 |
| `row_index` | integer | 指定计算行索引号（从0开始） |
| `from_col` | integer | 指定计算起始列索引号（从0开始） |
| `to_col` | integer | 指定计算起始列索引号（从0开始） |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return sumValueByRow2(t2, 1, 0, 1);
// 结果：36
```
## `sysErrorMessage(code)`
声明：function
返回指定代码表示的系统错误信息。
| 参数 | 类型 | 说明 |
| ------ | ---- | -------------- |
| `code` | int | 整数，提示代码 |
返回：string
## `sysGetThreadName(tid, return_value)`
声明：function
获取线程名称
| 参数 | 类型 | 说明 |
| -------------- | ------ | ------------------------------------------ |
| `tid` | int | 可选。线程ID；未指定时默认获取当前线程名称 |
| `return_value` | string | 获取成功，返回线程名称；否则，返回空字符串 |
返回：string
## `sysGetThreadPriority(pri, tid, return_value)`
声明：function
获取线程优先级
| 参数 | 类型 | 说明 |
| -------------- | ---- | -------------------------------------------- |
| `pri` | int | 变参，整数，线程优先级 |
| `tid` | int | 可选。线程ID；未指定时默认获取当前线程优先级 |
| `return_value` | int | 返回值为0，获取成功；否则，获取失败 |
返回：int
## `sysGetThreads(pid, return_value)`
声明：function
获取进程内的线程列表
| 参数 | 类型 | 说明 |
| -------------- | ----- | -------------------------------------------------- |
| `pid` | int | 可选。进程ID；未指定时默认获取当前进程内的线程列表 |
| `return_value` | array | 获取成功，返回线程ID列表；否则，返回空数组 |
返回：array
## `sysHandleOfPid(pid, rights, inherithandle, return_value)`
声明：function
Windows上获取进程id对应的句柄，Linux上获取指定文件ID的复制ID。得到的句柄可用函数FAQ：SysCloseHandle进行关闭。
| 参数 | 类型 | 说明 |
| --------------- | ---- | ------------------------------------------------------------------------------------------------------------ |
| `pid` | int | 整数，进程ID |
| `rights` | int | 可选。设置进程句柄权限，Linux上无效。常见的权限设置值如下： 更多说明，可参考微软官方文档：处理安全和访问权限 |
| `inherithandle` | bool | 可选。是否继承，Linux上无效 |
| `return_value` | 16 | 获取成功，返回进程句柄；否则，返回0 |
返回：IntPtr\|int
## `sysPidOfHandle(handle, return_value)`
声明：function
根据进程句柄获取进程ID。在Linux上，返回和进程句柄值相同的整数
| 参数 | 类型 | 说明 |
| -------------- | ---- | --------------------------------- |
| `handle` | int | 进程句柄 |
| `return_value` | int | 获取成功，返回进程ID；否则，返回0 |
返回：int
## `sysPidOfTid(tid, return_value)`
声明：function
获取线程所属进程ID
| 参数 | 类型 | 说明 |
| -------------- | ---- | --------------------------------- |
| `tid` | int | 整数，线程ID |
| `return_value` | int | 获取成功，返回进程ID；否则，返回0 |
返回：int
## `sysPPid(pid, return_value)`
声明：function
获得进程的父进程ID
| 参数 | 类型 | 说明 |
| -------------- | ---- | ------------------------------------------------ |
| `pid` | int | 可选。进程ID；未指定时默认获取当前进程的父进程ID |
| `return_value` | int | 获取成功，返回父进程ID；否则，返回0 |
返回：int
## `sysSetThreadName(name, tid, return_value)`
声明：function
设置线程名称
| 参数 | 类型 | 说明 |
| -------------- | ------ | ------------------------------------------ |
| `name` | string | 字符串，要设置的名称 |
| `tid` | int | 可选。线程ID；未指定时默认设置当前线程名称 |
| `return_value` | int | 返回值为0，设置成功；否则，设置失败 |
返回：int
## `sysSetThreadPriority(pri, tid, return_value)`
声明：function
设置线程优先级
| 参数 | 类型 | 说明 |
| -------------- | ---- | -------------------------------------------- |
| `pri` | int | 线程优先级 |
| `tid` | int | 可选。线程ID；未指定时默认设置当前线程优先级 |
| `return_value` | int | 返回值为0，设置成功；否则，设置失败 |
返回：int
## `sysWaitForSingleObject(object, wait_ms)`
声明：function
等待占有一个对象,例如互斥对象。支持windows和linux的进程
| 参数 | 类型 | 说明 |
| --------- | ---- | ------------------------------------ |
| `object` | int | 整数，对象名柄 |
| `wait_ms` | int | 整数，等待的毫秒数，-1则为永远等待。 |
返回：int
## `tableSelect(table, condition, reps)`
声明：function
表格查询。从t中查询满足Condition的子表
| 参数 | 类型 | 说明 |
| ----------- | ------ | ------ |
| `table` | any | 数据表 |
| `condition` | string | 字符串 |
| `reps` | string | 字符串 |
返回：array
### 示例
```tsl
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
return tableSelect(t, "~['b']=2", '~'); // 返回t中字段’b’=2的子表
// 返回:
```
## `TableType(t)`
声明：function
依据数组类型返回不同的值。
| 参数 | 类型 | 说明 |
| ---- | ----- | ---------------- |
| `t` | array | 数据表类型，数组 |
返回：integer
不是数组时返回 `-1`，以字符串返回的数组返回 `0`，以下标访问的数组返回 `1`。
### 示例
```tsl
data := array(array(1, 2), array(3, 4));
echo TableType(data);
```
## `tableVectorizeArray(t, s, opt, is_func)`
声明：function
数据表与一维数据表的矢量化运算。
| 参数 | 类型 | 说明 |
| --------- | ----------- | -------------------------------------- |
| `t` | array | 数据表 |
| `s` | array\|real | 一维数组 或实数， 运算标量 |
| `opt` | string | 字符串，操作运算符，默认"-",表逐行减法 |
| `is_func` | bool | 布尔，opt是否是函数，默认假 |
返回：array
### 示例
```tsl
t := ones(10, 3);
s := array(1, 2, 3);
return tableVectorizeArray(t, s, '-');
// 输出：
// array(
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2),
// (0,-1,-2))
```
## `tostring(v)`
声明：function
将数值转成字符串类型
| 参数 | 类型 | 说明 |
| ---- | ------ | ---- |
| `v` | number | 数值 |
返回：string
### 示例
```tsl
echo tostring(123.45);
```
## `totalStrToSeprate(s)`
声明：function
把用#分割的字符串转换为;分割
| 参数 | 类型 | 说明 |
| ---- | ------ | ------ |
| `s` | string | 字符串 |
返回：string
### 示例
```tsl
return totalStrToSeprate ('债券型#现金型#配置型#股票型#保本型');
// 结果：’债券型;现金型;配置型;股票型;保本型’
```
## `tryDecToInt(s, value)`
声明：function
将字符串转换为整数。若转换成功，转换值通过Value输出。
| 参数 | 类型 | 说明 |
| ------- | ------------ | ----------------------------------------------- |
| `s` | string | 字符串。需转换的字符串 |
| `value` | integer\|nil | 变参。转换成功，为转换后的整数；否则，为NIL值。 |
返回：bool
### 示例
范例01：转换成功
```tsl
ret := tryDecToInt("12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: 12
```
范例02：转换失败
```tsl
ret := tryDecToInt("test", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := tryDecToInt("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
ret := tryStrToInt("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出：18
```
## `tryDecToInt32(s, value)`
声明：function
将字符串转换为32位整数。若转换成功，转换值通过Value输出。
| 参数 | 类型 | 说明 |
| ------- | ------------ | ----------------------------------------------- |
| `s` | string | 字符串。需转换的字符串 |
| `value` | integer\|nil | 变参。转换成功，为转换后的整数；否则，为NIL值。 |
返回：bool
### 示例
范例01：转换成功
```tsl
ret := tryDecToInt32("12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: 12
```
范例02：转换失败
```tsl
ret := tryDecToInt32("test", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := tryDecToInt32("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
ret := tryStrToInt32("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出：18
```
## `tryDecToInt64(s, value)`
声明：function
将字符串转换为64位整数。若转换成功，转换值通过Value输出。
| 参数 | 类型 | 说明 |
| ------- | ------------ | ----------------------------------------------- |
| `s` | string | 字符串。需转换的字符串 |
| `value` | integer\|nil | 变参。转换成功，为转换后的整数；否则，为NIL值。 |
返回：bool
### 示例
范例01：转换成功
```tsl
ret := tryDecToInt64("12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: 12L
```
范例02：转换失败
```tsl
ret := tryDecToInt64("test", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
```
范例03：十六进制格式字符串的转换
```tsl
ret := tryDecToInt64("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出: "转换失败！"
ret := tryStrToInt64("0x12", value);
if ret then
return value;
else
return "转换失败！";
// 输出：18L
```
## `tryLowercase(s)`
声明：function
将字符串S转换成小写并返回，不抛出异常，转换失败时返回""
| 参数 | 类型 | 说明 |
| ---- | ------ | --------------- |
| `s` | string | 字符串,原字符串 |
返回：string
### 示例
```tsl
return tryUppercase("ABC");
// 结果:"abc"
```
## `tryStrToTime(s, value)`
声明：function
将字符串S转换成TDateTime类型的时间并存到参数Value中。如果转换成功，则返回真，否则返回假
| 参数 | 类型 | 说明 |
| ------- | -------- | ---------------------------------------- |
| `s` | string | 字符串，日期的字符串类型，如"2014-01-17" |
| `value` | datetime | 日期时间，转换结果（输出参数） |
返回：bool
## `tryUppercase(s)`
声明：function
将字符串S转换成大写并返回，不抛出异常，转换失败时返回""
| 参数 | 类型 | 说明 |
| ---- | ------ | --------------- |
| `s` | string | 字符串,原字符串 |
返回：string
### 示例
```tsl
return tryUppercase("abc");
// 结果:"ABC"
```
## `TwoRDateCompare_M1(t1, t2, r_date, r_date2, key_field, from_col, to_col, show_g_value, show_g_percent)`
声明：function
返回2个数据同比比较的结果。
| 参数 | 类型 | 说明 |
| ---------------- | -------- | -------------------------- |
| `t1` | array | 数组类型，数据1 |
| `t2` | array | 数组类型，数据2 |
| `r_date` | datetime | 报告期类型，报告期 |
| `r_date2` | any | 报告期类型，同比报告期 |
| `key_field` | string | 字符串类型，关键字 |
| `from_col` | any | 整型，要显示变比的开始列号 |
| `to_col` | any | 整型，要显示变比的截止列号 |
| `show_g_value` | bool | 布尔类型，显示变动 |
| `show_g_percent` | bool | 布尔类型，显示变比(%) |
返回：array
### 示例
```tsl
current_data := array(("code": "A", "value": 120));
previous_data := array(("code": "A", "value": 100));
echo trim(toStn(TwoRDateCompare_M1(
current_data,
previous_data,
20220331,
20210331,
"code",
0,
0,
true,
true
)));
```
## `unicodeEsc2()`
声明：function
多语言支持函数相关函数。
返回：string
## `unitary(t, key_fields, _type, f_value)`
声明：function
归一处理。对数组t指定列KeyFields进行归一处理，归一方式由Type决定。
| 参数 | 类型 | 说明 |
| ------------ | ---------------- | ---- |
| `t` | array,tablearray | |
| `key_fields` | string | |
| `_type` | integer | |
| `f_value` | integer | |
返回：array,tablearray
### 示例
```tsl
t := `array('a': (1, 2, 3, 4), 'b': (2, 3, 4, 5), 'c': (3, 4, 5, 6), 'd': (4, 5, 6, 7), 'e': (5, 6, 7, 8), 'f': (7, 8, 9, 10));
unitary(t, 'b', 0, 10);
return t;
// 返回:
// array(
// ("a":1,"b":10.0,"c":3,"d":4,"e":5,"f":7),
// ("a":2,"b":15.0,"c":4,"d":5,"e":6,"f":8),
// ("a":3,"b":20.0,"c":5,"d":6,"e":7,"f":9),
// ("a":4,"b":25.0,"c":6,"d":7,"e":8,"f":10))
```
## `varByColumn(t, f_name)`
声明：function
指定列的方差
| 参数 | 类型 | 说明 |
| -------- | ------ | ---------------- |
| `t` | array | 数据表 |
| `f_name` | string | 指定列名，字符串 |
返回：real
### 示例
```tsl
t2 := array(('a': 2, 'c': 13), ('a': 3, 'c': 33), ('a': 3, 'c': 43), ('a': 5, 'c': 53));
return varByColumn(t2, 'c');
// 结果：291.67
```
## `webFormatToRung(a)`
声明：function
将数组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":"-"))
```
## `webZero(v)`
声明：function
Web中显示零处理，当数值为0或者空字符串的时候显示为空字符串，其他情况显示其值本身；
| 参数 | 类型 | 说明 |
| ---- | -------------- | ------------ |
| `v` | integer/string | 任意类型的值 |
返回：string
### 示例
```tsl
return webZero(0);
// 结果：’’ //空字串
```
## `wrapText(col, row)`
声明：function
单元格的是否换行
| 参数 | 类型 | 说明 |
| ----- | ------ | ------------------------- |
| `col` | string | 整数，列的位置，从0开始。 |
| `row` | int | 整数，行的位置，从0开始。 |
返回：string
## `zValue(t, column_name)`
声明：function
按照指定字段求Z值。
| 参数 | 类型 | 说明 |
| ------------- | ------ | ------------------------ |
| `t` | array | 数据表类型，数据表 |
| `column_name` | string | 字符串，要计算Rank的字段 |
返回：any
### 示例
```tsl
s := array(
("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892),
("代码":"SZ000002","名称":"万 科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225),
("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115),
("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175));
zValue(s, '涨幅(%)');
return s;
// 返回:
// array(
// ("代码":"SZ000001","名称":"平安银行","收盘":11.2,"涨幅(%)":0.900900900900892,"Z_涨幅(%)":0.246104637421774),
// ("代码":"SZ000002","名称":"万 科Ａ","收盘":27.68,"涨幅(%)":-0.25225225225225,"Z_涨幅(%)":-1.11516496413374),
// ("代码":"SH600000","名称":"浦发银行","收盘":10.77,"涨幅(%)":0.372786579683115,"Z_涨幅(%)":-0.37732163484235),
// ("代码":"SH600100","名称":"同方股份","收盘":8.73,"涨幅(%)":1.74825174825175,"Z_涨幅(%)":1.24638196155432))
```
Reference in New Issue View Git Blame Copy Permalink