# 运行时 / 数学与统计

## `Anova_Bartlett(y, alpha)`

在1-alpha的置信水平下，Bartlett方法检验方差齐性；B-Stat为统计值，P-Value为p值，df为自由度，Hypothesis为是否接受原假设 模型表达： Bartlett检验思想来源于几何平均数小于或等于算术平均数 原假设：是水平个数 ,其中 修正的Bartlett检验：

| 参数    | 类型  | 说明                                         |
| ------- | ----- | -------------------------------------------- |
| `y`     | array | 数据矩阵，为二维数组类型，每一行表示一个水平 |
| `alpha` | float | 显著性水平，实数或整数，在01之间             |

返回：array

## `Anova_Levene(y, alpha)`

在1-Alpha的置信水平下，Levene方法检验方差齐性，和Bartlett检验不同的是，Levene检验不要求总体具有正态性。返回一个数组，F-Stat为统计值，P-Value为p值，df1，df2为自由度，Hypothesis为是否接受原假设 模型表达： 原假设：是水平个数 ，其中是观察数目，是水平数目

| 参数    | 类型  | 说明                                         |
| ------- | ----- | -------------------------------------------- |
| `y`     | array | 数据矩阵，为二维数组类型，每一行表示一个水平 |
| `alpha` | float | 显著性水平，实数或整数，在01之间             |

返回：array

## `Anova_Single(y, alpha)`

在1-alpha置信水平下，在假设服从正态分布，且方差齐性，样本之间独立的基础上，判断各水平的均值是否显著相等 模型表达： ， 其中：效应平方和：，误差平方和： 总离差

| 参数    | 类型  | 说明                                         |
| ------- | ----- | -------------------------------------------- |
| `y`     | array | 数据矩阵，为二维数组类型，每一行表示一个水平 |
| `alpha` | float | 显著性水平，实数或整数，在01之间             |

返回：array

## `Anova_Twice(y, alpha)`

在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

## `arma(series, p, q)`

自回归移动平均模型，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);
```

## `Cluster_Kmeans(samples, class_count, options)`

执行 K-means 聚类。

| 参数          | 类型  | 说明                                                   |
| ------------- | ----- | ------------------------------------------------------ |
| `samples`     | array | 样本矩阵                                               |
| `class_count` | any   | 聚类数量                                               |
| `options`     | array | 参数表；常见键包括 `maxiter`、`tol`、`distance`、`out` |

返回：array

## `Cluster_ward(samples)`

执行 Ward 聚类。

| 参数      | 类型  | 说明     |
| --------- | ----- | -------- |
| `samples` | array | 样本矩阵 |

返回：array

## `correlationMatrix(a1, t)`

相关系数矩阵求解

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `a1` | array |      |
| `t`  | float |      |

返回：array

### 示例

```tsl
a := rand(4,3);
correlationMatrix(a,1);
```

## `Corr_partial(x, y, z, _type)`

偏相关系数，返回x和y在控制变量z下的偏相关系数，行为样本，列为指标

| 参数    | 类型  | 说明                                                                                                             |
| ------- | ----- | ---------------------------------------------------------------------------------------------------------------- |
| `x`     | array | 变量一，二维实数数组                                                                                             |
| `y`     | array | 变量二，二维实数数组                                                                                             |
| `z`     | array | 控制变量，二维实数数组                                                                                           |
| `_type` | any   | 1:pearson偏相关;2:Spearman偏相关；tail:假设检验的三种类型，字符串，取值为both、left和right，缺省是只输出相关系数 |

返回：any

## `covariance(a)`

计算协方差矩阵

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `a`  | array |      |

返回：any

### 示例

```tsl
a := rand(4,3);
covariance(a);
```

## `Eigen_Jacobi(matrix, eigen_values, eigen_vectors)`

用 Jacobi 方法计算矩阵特征值和特征向量。

| 参数            | 类型  | 说明             |
| --------------- | ----- | ---------------- |
| `matrix`        | array | 待分解矩阵       |
| `eigen_values`  | any   | 接收特征值数组   |
| `eigen_vectors` | any   | 接收特征向量矩阵 |

返回：void

## `eye(size)`

生成单位矩阵。

| 参数   | 类型 | 说明                                       |
| ------ | ---- | ------------------------------------------ |
| `size` | any  | 行数和列数；`eye(3)` 生成 `3 x 3` 单位矩阵 |

返回：array

## `factor(x, var_value)`

对样本数据进行因子分析，分别采用主成分分析法估计因子载荷矩阵（因子载荷矩阵不唯一），方差最大法做载荷矩阵的正交旋转矩阵，回归方法计算因子得分

| 参数        | 类型  | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ----------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `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;
```

## `histc(a, b)`

端点定位频数，判断序列a 中各个元素在b中各个段位中的频数

| 参数 | 类型  | 说明     |
| ---- | ----- | -------- |
| `a`  | array | 一维数组 |
| `b`  | array | 一维数组 |

返回：array

### 示例

```tsl
a:=rand(1000)*5;
b:=array(0,1,2,3,4,5);
histc(a,b);
```

## `Hypoth_LSUTest(mx, s, n, u, tail, alpha)`

单个或两个总体大样本的均值检验，即大样本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_PSignTest(x, pi, q0, tail, alpha)`

非参数检验-配对样本符号检验,配对样本的符号检验 要求样本矩阵中两个样本是配对出现的 可以按照实际需求选择双侧或单侧检验

| 参数    | 类型   | 说明                                    |
| ------- | ------ | --------------------------------------- |
| `x`     | array  | 一维数字数组,样本矩阵                   |
| `pi`    | float  | 实数,分位点                             |
| `q0`    | float  | 实数,检验值                             |
| `tail`  | string | 字符串,双侧检验 or 左侧检验 or 右侧检验 |
| `alpha` | float  | 实数,显著性水平                         |

返回：array

## `Hypoth_SignTest(x, pi, q0, tail, alpha)`

非参数检验-符号检验。对单样本进行符号检验 可以按照实际需求选择双侧或单侧检验 其中，检验变量服从二项分布

| 参数    | 类型   | 说明                                                                                    |
| ------- | ------ | --------------------------------------------------------------------------------------- |
| `x`     | array  | 样本序列，为一维数字数组类型                                                            |
| `pi`    | float  | 分位点，为实数类型                                                                      |
| `q0`    | float  | 检验值，即检验分位点的值，为实数类型                                                    |
| `tail`  | string | 假设检验的三种类型，both（双侧检验），left（左侧检验），right（右侧检验），为字符串类型 |
| `alpha` | float  | 显著性水平，在0-1之间，为实数类型                                                       |

返回：array

## `Hypoth_SNDTest(x, d2, tail, alpha)`

单个正态总体方差的卡方检验，返回的结果是一个数组，第一个数为统计值，二为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)`

单个正态总体的均值检验，分为标准差未知和已知两个情况，返回结果是一个数组，第一个数为统计值，二为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_TNDTest(x, tail, alpha)`

两个正态总体方差比的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)`

两个正态总体均值差的检验，分为标准差未知和已知两个情况，返回的结果是一个数组，第一个数为统计值，二为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

## `ig_Chebyshev(a, b, call_back, v)`

数值计算相关函数。

| 参数        | 类型   | 说明 |
| ----------- | ------ | ---- |
| `a`         | any    |      |
| `b`         | any    |      |
| `call_back` | string |      |
| `v`         | any    |      |

返回：any

## `ig_Gauss(a, b, call_back, v)`

数值计算相关函数。

| 参数        | 类型   | 说明 |
| ----------- | ------ | ---- |
| `a`         | any    |      |
| `b`         | any    |      |
| `call_back` | string |      |
| `v`         | any    |      |

返回：any

## `ip_Aitken_A(x, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | array |      |
| `y`  | array |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Aitken_B(x0, h, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x0` | float |      |
| `h`  | float |      |
| `y`  | array |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Hermite_A(x, y, dy, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | array |      |
| `y`  | any   |      |
| `dy` | any   |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Hermite_B(x0, h, y, dy, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x0` | any   |      |
| `h`  | any   |      |
| `y`  | array |      |
| `dy` | array |      |
| `xv` | float |      |
| `yv` | any   |      |

返回：any

## `ip_Lagrangian_A(x, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | array |      |
| `y`  | any   |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Lagrangian_B(x0, h, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x0` | float |      |
| `h`  | float |      |
| `y`  | array |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Parabola_A(x, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | array |      |
| `y`  | array |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Parabola_B(x0, h, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x0` | float |      |
| `h`  | float |      |
| `y`  | array |      |
| `xv` | any   |      |
| `yv` | any   |      |

返回：any

## `ip_Spline_A(x, y, dy0, dyn_1, xv, yv)`

数值计算相关函数。

| 参数    | 类型  | 说明 |
| ------- | ----- | ---- |
| `x`     | array |      |
| `y`     | array |      |
| `dy0`   | any   |      |
| `dyn_1` | any   |      |
| `xv`    | float |      |
| `yv`    | any   |      |

返回：any

## `ip_Spline_B(x, y, ddy0, ddyn_1, xv, yv)`

数值计算相关函数。

| 参数     | 类型  | 说明 |
| -------- | ----- | ---- |
| `x`      | array |      |
| `y`      | array |      |
| `ddy0`   | any   |      |
| `ddyn_1` | any   |      |
| `xv`     | float |      |
| `yv`     | any   |      |

返回：any

## `ip_Spline_C(x, y, xv, yv)`

数值计算相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | array |      |
| `y`  | array |      |
| `xv` | float |      |
| `yv` | any   |      |

返回：any

## 一般统计量

## `LeastSquares_CurveFitting(f, y)`

最小二乘法进行回归

| 参数 | 类型  | 说明                         |
| ---- | ----- | ---------------------------- |
| `f`  | array | 二维数字数组类型，系数矩阵   |
| `y`  | array | 一维数字数组类型，观察数据值 |

返回：array

## `mcols(value, mode)`

读取矩阵样数据或 FMArray 的列数或列索引。

| 参数    | 类型  | 说明                                    |
| ------- | ----- | --------------------------------------- |
| `value` | array | 输入数据                                |
| `mode`  | any   | 省略时返回列数；传 `1` 时返回列索引数组 |

返回：array

## `mrows(value, mode)`

读取矩阵样数据或 FMArray 的行数或行索引。

| 参数    | 类型  | 说明                                    |
| ------- | ----- | --------------------------------------- |
| `value` | array | 输入数据                                |
| `mode`  | any   | 省略时返回行数；传 `1` 时返回行索引数组 |

返回：array

## `msize(value, mode)`

读取矩阵样数据或 FMArray 的尺寸信息。

| 参数    | 类型  | 说明                                      |
| ------- | ----- | ----------------------------------------- |
| `value` | array | 输入数据                                  |
| `mode`  | any   | 省略时返回各维长度；传 `1` 时返回索引数组 |

返回：array

## `multipleRegression(x, y, call_back)`

多元回归

| 参数        | 类型   | 说明                           |
| ----------- | ------ | ------------------------------ |
| `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);
//结果：
```

## `NonLP_Fminbnd(fun, a, b, methods)`

一维最小值搜索，求解模型如下： min fun(x)

| 参数      | 类型   | 说明                                                                           |
| --------- | ------ | ------------------------------------------------------------------------------ |
| `fun`     | string | 目标函数(函数名字符串)                                                         |
| `a`       | float  | 下界，实数                                                                     |
| `b`       | float  | 上界，实数                                                                     |
| `methods` | any    | 方法选择0 :黄金分割法+抛物线法（默认）1 : 盲人收索法2 :黄金分割法3 :斐波那契法 |

返回：array

## `NonLP_Rosenbrock(fun, x0)`

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）Rosenbrock求无约束多维极值问题，返回最优点和最优值。

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `numberOfPeriods(rate, payment, present_value, future_value, payment_time)`

返回投资的期数，也就是按照指定的收益率和每期的付款，现值PresentValue要经过多少个周期才能到达FutureValue的数值。

| 参数            | 类型  | 说明                                             |
| --------------- | ----- | ------------------------------------------------ |
| `rate`          | float | 实数，收益率                                     |
| `payment`       | float | 实数。每期付款额                                 |
| `present_value` | float | 实数，现值                                       |
| `future_value`  | int   | 实数，要达到的终值                               |
| `payment_time`  | float | PaymentTime决定Payment的支付是在期初还是期末发生 |

返回：float

## `ozProg(f, a, b)`

（线性规划，包括整数规划，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
```

## `Prog_Q(h, f, a, b, aeq, beq, lb, ub, x0, options)`

二次规划问题求解(采用作用集方法) 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

## `rand(rows, cols)`

生成随机矩阵样结果。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `rows` | any  | 行数 |
| `cols` | any  | 列数 |

返回：array

## 数学函数 / FMArray 函数

## `randgam(a, b, row, col)`

产生伽马分布的随机数

| 参数  | 类型  | 说明                   |
| ----- | ----- | ---------------------- |
| `a`   | float | 形状参数,大于0的实数   |
| `b`   | float | 尺度参数,大于0的实数   |
| `row` | array | 行数或者行名字符串数组 |
| `col` | array | 列数或者列名字符串数组 |

返回：any

### 示例

```tsl
randgam(2,2,100,array("a","b"));
```

## `Regress_CMLS(y, x, u, constant)`

线性回归方程的最小二乘法参数估计（可选择是否包含常数项），返回回归方程的系数，如果有常数项则排在第一项

| 参数       | 类型  | 说明                                               |
| ---------- | ----- | -------------------------------------------------- |
| `y`        | array | 被解释变量序列，为一维数组类型                     |
| `x`        | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `u`        | array | 残差序列，为一维数组类型，变参                     |
| `constant` | bool  | 是否包含常数项，为布尔类型，缺省为true             |

返回：array

## `Regress_domin_formula(y, x)`

相对重要性分析-R2公式分解法 功能描述： 1、相对重要性分析 2、算法：根据含常数项的多元回归的r2的分解公式，来计算 不同解释变量的相对贡献度 3、公式法： 未考虑到不同解释变量之间的相互关系， 贡献度可能为负数

| 参数 | 类型  | 说明                   |
| ---- | ----- | ---------------------- |
| `y`  | array | Array of number,因变量 |
| `x`  | array | Array of number,自变量 |

返回：array

## `Regress_DWTest(u)`

德宾-沃森检验：检验随机误差项是否存在一阶自相关。结果返回DW统计量 DW统计量：（一般认为值在2附近，则随机误差项不存在自相关）

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `u`  | array | 方程残差，为一维数组类型； |

返回：any

## `Regression_OLS_NW(y, x, constant, alpha, al)`

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

## `Regress_MLS(y, x, u)`

线性回归方程的最小二乘法参数估计（包含常数项），返回回归方程的系数，常数项排在第一项

| 参数 | 类型  | 说明                                               |
| ---- | ----- | -------------------------------------------------- |
| `y`  | array | 被解释变量序列，为一维数组类型                     |
| `x`  | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `u`  | array | 残差序列，为一维数组类型，变参                     |

返回：array

## `Regress_Ridge(y_values, x_values, k_values, trace_mode)`

执行岭回归，或按 `k_values` 输出岭迹。

| 参数         | 类型  | 说明                       |
| ------------ | ----- | -------------------------- |
| `y_values`   | array | 因变量样本                 |
| `x_values`   | array | 自变量样本矩阵             |
| `k_values`   | array | 岭参数序列；省略时自动选择 |
| `trace_mode` | bool  | 是否按岭迹模式输出         |

返回：array

## `Regress_TTest_RWLS(x, a, u, k, alpha, constant, weight, restrictiveness)`

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_WLS(y_values, x_values, weights, residuals)`

执行加权最小二乘回归并输出残差。

| 参数        | 类型  | 说明         |
| ----------- | ----- | ------------ |
| `y_values`  | array | 因变量样本   |
| `x_values`  | array | 自变量样本   |
| `weights`   | array | 权重序列     |
| `residuals` | any   | 接收残差序列 |

返回：array

## `sf_Beta(arg1, arg2, v)`

统计分布相关函数。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any  |      |
| `arg2` | any  |      |
| `v`    | any  |      |

返回：any

## `sf_betainv(y, arg2, arg3, x)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `y`    | array |      |
| `arg2` | any   |      |
| `arg3` | any   |      |
| `x`    | any   |      |

返回：any

## 常用数学函数

## `sf_betapdf(x, a, b, v)`

贝塔分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | beta分布参数1,实数,大于0                      |
| `b`  | float | beta分布参数2,实数,大于0                      |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_CosX(arg1, v)`

数值计算相关函数。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any  |      |
| `v`    | any  |      |

返回：any

## `sf_EllipseX_1(k, f, v)`

数值计算相关函数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `k`  | any  |      |
| `f`  | any  |      |
| `v`  | any  |      |

返回：any

## `sf_EllipseX_2(k, f, v)`

数值计算相关函数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `k`  | any  |      |
| `f`  | any  |      |
| `v`  | any  |      |

返回：any

## `sf_Error(arg1, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `v`    | any   |      |

返回：any

## `sf_eX(arg1, v)`

数值计算相关函数。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any  |      |
| `v`    | any  |      |

返回：any

## `sf_F(f, n1, n2, v)`

统计分布相关函数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `f`  | any  |      |
| `n1` | any  |      |
| `n2` | any  |      |
| `v`  | any  |      |

返回：any

## `sf_finv(arg1, arg2, arg3, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `arg2` | any   |      |
| `arg3` | any   |      |
| `v`    | any   |      |

返回：any

## `sf_Gamma(arg1, v)`

统计分布相关函数。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any  |      |
| `v`    | any  |      |

返回：any

## `sf_gammainv(arg1, arg2, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `arg2` | any   |      |
| `v`    | any   |      |

返回：any

## `sf_IncompleteBeta(a, b, x, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `a`  | any   |      |
| `b`  | any   |      |
| `x`  | float |      |
| `v`  | any   |      |

返回：any

## `sf_IncompleteGamma(a, x, v)`

统计分布相关函数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `a`  | any  |      |
| `x`  | any  |      |
| `v`  | any  |      |

返回：any

## `sf_IntegerBessel_1(n, x, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `n`  | any   |      |
| `x`  | float |      |
| `v`  | any   |      |

返回：any

## `sf_IntegerBessel_2(n, x, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `n`  | any   |      |
| `x`  | float |      |
| `v`  | any   |      |

返回：any

## `sf_Normal(x, a, d, v)`

统计分布相关函数。

| 参数 | 类型 | 说明 |
| ---- | ---- | ---- |
| `x`  | any  |      |
| `a`  | any  |      |
| `d`  | any  |      |
| `v`  | any  |      |

返回：any

## `sf_normalinv(arg1, arg2, arg3, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `arg2` | any   |      |
| `arg3` | any   |      |
| `v`    | any   |      |

返回：any

## `sf_normalinv2(arg1, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `v`    | any   |      |

返回：any

## `sf_RealBessel_1(n, x, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `n`  | any   |      |
| `x`  | float |      |
| `v`  | any   |      |

返回：any

## `sf_RealBessel_2(n, x, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `n`  | any   |      |
| `x`  | float |      |
| `v`  | any   |      |

返回：any

## `sf_SinX(arg1, v)`

数值微积分相关函数。

| 参数   | 类型 | 说明 |
| ------ | ---- | ---- |
| `arg1` | any  |      |
| `v`    | any  |      |

返回：float

## `sf_t(t, n, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `t`  | float |      |
| `n`  | any   |      |
| `v`  | any   |      |

返回：any

## `sf_tinv(arg1, arg2, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `arg2` | any   |      |
| `v`    | any   |      |

返回：any

## `sf_X2(x, n, v)`

统计分布相关函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float |      |
| `n`  | any   |      |
| `v`  | any   |      |

返回：any

## `sf_x2inv(arg1, arg2, v)`

统计分布相关函数。

| 参数   | 类型  | 说明 |
| ------ | ----- | ---- |
| `arg1` | float |      |
| `arg2` | any   |      |
| `v`    | any   |      |

返回：any

## `SingleUnLineralRegression_CallBack(x)`

单元非线性回归的回调函数

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `x`  | array | 一维数字数组类型 |

返回：array

## `Time_ACF(y)`

自相关系数，计算随机序列与所有滞后阶数的相关系数。

| 参数 | 类型  | 说明                                                                          |
| ---- | ----- | ----------------------------------------------------------------------------- |
| `y`  | array | 数组，样本序列；；p:整数，返回样本自相关系数序列的长度，默认值为3，允许缺省； |

返回：array

## `Time_Analyse(y, model, p, q, l)`

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)`

自回归条件异方差模型，本模型的ARCH模型如下： sss 可把异方差方程进行整合，得到 用最小二乘法去估计方程的系数了，得到系数的相合估计。 或者用最大似然估计去估计参数，得到精度估计，最大似然估计的目标函数值为：

| 参数       | 类型  | 说明                         |
| ---------- | ----- | ---------------------------- |
| `r_series` | array | 资产收益率，为一维数组类型； |
| `q`        | any   | 自回归阶数，为整数类型；     |
| `l`        | any   | 预测步长，为整数类型         |

返回：array

## `Time_ARCHTest(u, q, alpha)`

时间序列异方差的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)`

建议使用ARMA模型替换，自回归移动平均模型，ARMA(p,q)模型，采用逆函数去估计自回归系数和移动平均系数，返回结果有自回归系数、移动平均系数、残差方差、预测值及预测波动。 估计过程如下： ，为自协方差 其中：yt为原序列零均值化的新序列，μ为原序列的均值，ρp是自相关系数，φq是自回归方程系数，θq为移动平均系数，εt是零均值、方差为σ2的平稳白噪声

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `y`  | array | 样本序列，为一维数组类型； |
| `p`  | any   | 自回归阶数；               |
| `q`  | any   | 移动平均阶数               |
| `l`  | any   | 预测步长，整数             |

返回：array

## `Time_ARp(y, p, l)`

建议使用AR模型替换，自回归模型，AR(p)模型，用Yule-Walker方程去估计p阶自回归模型的系数，返回结果有自回归系数、残差方差、预测值及预测波动。估计过程如下 AR(p)模型： 如有常数项，则 ，为自协方差 其中：为原序列零均值化的新序列，为原序列的均值，是自相关系数，是自回归方程系数，是零均值，方差为的平稳白噪声

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `y`  | array | 样本序列，为一维数组类型； |
| `p`  | any   | 自回归阶数；               |
| `l`  | any   | 预测步长；                 |

返回：array

## `Time_AutoCov(y, l)`

自协方差，求样本序列跟滞后L阶序列的协方差，即自协方差 自协方差计算公式如下： 其中：yt是样本序列，yL是滞后L阶的序列。

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `y`  | array | 样本序列，为一维数组类型； |
| `l`  | any   | 滞后阶数，为整数类型；     |

返回：any

## `Time_ChoseP(y, model, f)`

判断AR模型最佳的阶数，采用信息准则函数判断模型的最佳阶数 其中：T为样本容量，K为待估计参数

| 参数    | 类型   | 说明                                   |
| ------- | ------ | -------------------------------------- |
| `y`     | array  | 样本序列，为一维数组类型；             |
| `model` | string | 模型类别为AR、MA、ARMA，为字符串类型； |
| `f`     | string | 判断准则为SBIC和AIC，为字符串类型      |

返回：any

## `Time_DanielTest(y, alpha)`

在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)`

序列差分

| 参数 | 类型  | 说明                    |
| ---- | ----- | ----------------------- |
| `y`  | array | 需要做差分的数组数据    |
| `n`  | any   | 差分的阶数，0阶不做处理 |

返回：any

## `Time_GARCH(rseries, model)`

广义自回归条件异方差模型，包含四种模型：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_InvFun(ap, mq)`

中间函数，模型逆函数，ARMA模型的逆函数，Green函数的递推公式如下： 式中： ，，是自回归方程系数，为移动平均系数，

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `ap` | array | 自相关系数，为一维数组类型；   |
| `mq` | array | 移动平均系数，为一维数组类型； |

返回：array

## `Time_MAq(y, q, l)`

建议使用ARMA模型替换，移动平均模型，MA(q)模型，用条件最小二乘法去估计q阶移动平均模型的系数，返回结果有移动平均系数、残差方差、预测值及预测波动。 估计过程如下： MA(q)模型： 具有逆转形式： 用算子形式比较，可得： s 条件最小二乘法使得下列残差平方和最小： 可将上述转化为矩阵形式，先求得的取值，在利用上上式计算移动平均系数 如有常数，则常数项为原序列的均值。 ，为自协方差 其中：yt为原序列零均值化的新序列，μ为原序列的均值，θq为移动平均系数，εt是零均值，方差为σ2的平稳白噪声

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `y`  | array | 样本序列，为一维数组类型； |
| `q`  | any   | 移动平均阶数；             |
| `l`  | any   | 预测步长；                 |

返回：array

## `Times_Cointergration(y, x, alpha)`

建议使用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)`

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)`

两变量间的误差修正模型，准确的刻画了两序列间的短期波动特征 误差修正模型是时间序列间协整关系的主要表现形式，准确的刻画了序列间的长期均衡关系和短期波动特征。设一阶自回归分布滞后模型为： 其中，是均值为零，方差为的白噪声，进行适当的整理有： 其中若记 称为误差修正项。

| 参数    | 类型  | 说明                                         |
| ------- | ----- | -------------------------------------------- |
| `y`     | array | 被解释变量，为一维数组类型                   |
| `x`     | array | 解释变量，为一维数组类型                     |
| `resid` | array | 协整检验时的残差，没有输入，使用最小二乘得到 |
| `alpha` | float | 显著性水平                                   |
| `q`     | any   | 整数类型，被解释变量的滞后项                 |
| `p`     | any   | 整数类型，解释变量的滞后项                   |

返回：any

## `timeSeriesSplit()`

时间序列数据处理；将时间序列数据：时间、数据、（股票）处理成为（时间股票数据）的格式。注意，该函数主要用于客户端结果处理，不提供给用户程序编辑。

返回：array

## `Times_Granger(y, x, q, alpha)`

Granger因果检验，原假设：X不是Y的Granger原因，Hypothesis为1表示接受原假设，0表示拒绝原假设 原假设： 分别对上述两个回归方程做回归，提取残差平方和XESS跟YESS，则F统计量如下计算：

| 参数    | 类型  | 说明                                  |
| ------- | ----- | ------------------------------------- |
| `y`     | array | 被解释变量，为一维数组类型            |
| `x`     | array | 解释变量，为一维数组类型              |
| `q`     | any   | 滞后阶数，为整数类型                  |
| `alpha` | float | 显著性水平，为实数类型，一般在0-1之间 |

返回：array

## `Times_johansen(x, p, k)`

进行Johansen协整检验，第一列的迹、最大特征值统计量的原假设是：没有协整关系；第二列的迹、最大特征值统计量的原假设是最多只有一个协整关系；第三列的迹、最大特征值统计量的原假设是最多只有两个协整关系……

| 参数 | 类型  | 说明                                                                                                                   |
| ---- | ----- | ---------------------------------------------------------------------------------------------------------------------- |
| `x`  | array | 输入多元时间序列,每一列为一指标，每行为一时间 (nobs\*m)                                                                |
| `p`  | any   | 是否含时间趋势及常数项p = -1,没有时间趋势以及常数项p =0,含常数项p =1,含常数项以及一次时间项p >1,含常数项以及高次时间项 |
| `k`  | any   | 滞后阶数                                                                                                               |

返回：array

## `zeros(size_or_rows, cols_or_fields)`

生成元素为 `0` 的一维或二维矩阵样结果。

| 参数             | 类型  | 说明                 |
| ---------------- | ----- | -------------------- |
| `size_or_rows`   | any   | 一维长度或二维行数   |
| `cols_or_fields` | array | 二维列数，或列名数组 |

返回：array

## `correlMatrix(stocks, start_date)`

股票列表之间的相关系数。与当前时间有关，当前时间为区间截止日。

| 参数         | 类型      | 说明                     |
| ------------ | --------- | ------------------------ |
| `stocks`     | Array     | 一维字符串数组，股票列表 |
| `start_date` | TDateTime | 日期型时间，开始计算日期 |

返回：TableArray

### 示例

```tsl
//组合个股相关矩阵
setSysParam(pn_date(),20201231T);
stocks:=array("SH600718","SZ000920");
return correlMatrix(stocks,intToDate(20120926));
//结果：
```

## `symOrthogonal(data, option)`

对矩阵进行正交

| 参数     | 类型       | 说明                                                  |
| -------- | ---------- | ----------------------------------------------------- |
| `data`   | Array      | 二维数字数组, 二维数组 行下标为数字或字符串的二维数组 |
| `option` | UserDefine | 用户自定义, 正交方法的选择                            |

返回：array

### 示例

```tsl
范例01
//求data的对称正交矩阵
data := rand(10,3);
return symOrthogonal(data,0);
//结果，随机数，每次结果不一样，仅供参考
```

## `covarianceAttenuation(a)`

协方差矩阵-衰减因子。

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 二维数字数组 |

返回：any

### 示例

```tsl
a:=array((1,2,3),(4,5,6));
return covarianceAttenuation(a);
返回:
```

## `giniCoeff(x, y, method)`

计算基尼系数，其中Method决定使用的方法。

| 参数     | 类型 | 说明 |
| -------- | ---- | ---- |
| `x`      |      |      |
| `y`      |      |      |
| `method` |      |      |

返回：real

### 示例

```tsl
x:=array(0.1,0.2,0.3,0.4,0.5,0.6);
y:=x^2;
return giniCoeff(x,y,1);
//返回:0.07
```

## `hurst(data, n_rs, options)`

计算hurst指数

| 参数      | 类型  | 说明                                                       |
| --------- | ----- | ---------------------------------------------------------- |
| `data`    | Array | 一维数字数组,用于求hurst的收益率数据                       |
| `n_rs`    | Array | 二维数字数组,作为变参输出回归数据n和R/S                    |
| `options` | Array | 二维数字数组,方法选项，默认方法选项 "minEle":10,"maxSur":0 |

返回：real

### 示例

```tsl
data:=spec(fundNawzfQk(20240308t,20240831t,cy_day(),0,0), "OF000001");
t := sselect ["净值收益率(%)"] from data end;
return hurst(t);// 0.47
```

## `weightedMedian(x, w)`

加权中位数

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
echo median(x); //返回3
return weightedMedian(x, w); //返回4
```

## `weightedGeomean(x, w)`

加权几何平均数

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
return weightedGeomean(x,w); //3.0261
```

## `weightedHarmean(x, w)`

加权调和平均数

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
return weightedHarmean(x,w); //2.553
```

## `weightedMean(x, w)`

加权平均数

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
return weightedMean(x,w); //3.4
```

## `weightedPopnVariance(x, w)`

加权总体方差

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
return weightedPopnVariance(x,w); //1.84
```

## `weightedVariance(x, w)`

可靠性权重加权样本方差

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
return weightedVariance(x,w); //2.374
```

## `weightedPopnCov(a, b, w)`

加权总体协方差

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | Array | 一维数字数组 |
| `b`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
y := array(6,4,3,1,9);
return weightedPopnCov(x,y,w);// 0.82
```

## `weightedCov(a, b, w)`

可靠性权重加权样本协方差

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | Array | 一维数字数组 |
| `b`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
y := array(6,4,3,1,9);
return weightedCov(x,y,w); // 1.058
```

## `weightedPopnCovariance(a, w)`

加权总体协方差矩阵

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `a`  | Array | 待计算的矩阵，每一列为一个因子 |
| `w`  | Array | 一维权重向量                   |

返回：Matix

### 示例

```tsl
begt := 20190101T;
endt := 20190415T;
stocks := array('SH000001','SH000300','SH600000');
//涨幅(%)矩阵
returns := pf_GetPortfolioRate(stocks,begt,endt,1)[:,1:];
//指数函数权重
n := length(returns);
w := exp(1->n);
w /= sum(w);
return weightedPopnCovariance(returns, w);
//结果
```

## `weightedCovariance(a, w)`

可靠性权重加权样本方差矩阵

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `a`  | Array | 待计算的矩阵，每一列为一个因子 |
| `w`  | Array | 一维权重向量                   |

返回：matrix

### 示例

```tsl
begt := 20190101T;
endt := 20190415T;
stocks := array('SH000001','SH000300','SH600000');
//涨幅(%)矩阵
returns := pf_GetPortfolioRate(stocks,begt,endt,1)[:,1:];
//指数函数权重
n := length(returns);
w := exp(1->n);
w /= sum(w);
return weightedCovariance(returns, w);
//结果
```

## `weightedCorrel(a, b, w)`

加权相关系数

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | Array | 一维数字数组 |
| `b`  | Array | 一维数字数组 |
| `w`  | Array | 一维权重向量 |

返回：real

### 示例

```tsl
x := array(1,2,3,4,5);
w := array(0.15,0.1,0.2,0.3,0.25);
y := array(6,4,3,1,9);
return weightedCorrel(x,y,w); //0.1956
```

## `weightedCorrelM(a, w)`

加权相关系数矩阵

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `a`  | Array | 待计算的矩阵，每一列为一个因子 |
| `w`  | Array | 一维权重向量                   |

返回：matrix

### 示例

```tsl
begt := 20190101T;
endt := 20190415T;
stocks := array('SH000001','SH000300','SH600000');
//涨幅(%)矩阵
returns := pf_GetPortfolioRate(stocks,begt,endt,1)[:,1:];
//指数函数权重
n := length(returns);
w := exp(1->n);
w /= sum(w);
return weightedCorrelM(returns, w);
//结果
```

## `ewmMean(x, y, alphatype, adjust, iflast)`

指数加权移动平均，支持nan，为nan的值参与权重计算，但计算平均时对nan值不进行计算，即计算加权平均时把nan 值及其权重都置为0进行计算

| 参数        | 类型    | 说明                                                                                                               |
| ----------- | ------- | ------------------------------------------------------------------------------------------------------------------ |
| `x`         | Array   | 数组，待计算移动平均的一维数字数组                                                                                 |
| `y`         | real    | 实数，衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                           |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                                |
| `adjust`    | bool    | 布尔型，是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |
| `iflast`    | bool    | 是否只返回最后一个数，默认为False                                                                                  |

返回：Array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
x := nDay3(50,stockZf3());
return x | ewmMean(x,10,1);
//结果
```

## `ewmStd(x, y, alphatype, adjust)`

指数加权移动标准差

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `x`         | Array   | 待计算移动平均的一维数字数组                                                                               |
| `y`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：Array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
x := nDay3(50,stockZf3());
return x | ewmStd(x,10,1);
//结果
```

## `ewmVar(x, y, alphatype, adjust)`

指数加权移动方差，支持nan，为nan的值参与权重计算，但计算平均时对nan值不进行计算，即计算加权平均时把nan 值及其权重都置为0进行计算，（有偏暂未实现支持nan）

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `x`         | Array   | 待计算移动平均的一维数字数组                                                                               |
| `y`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：Array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
x := nDay3(50,stockZf3());
return x | ewmVar(x,10,1);
//结果
```

## `ewmCorrel(a, b, y, alphatype, adjust, iflast)`

指数加权移动相关系数

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `a`         | Array   | 样本a待计算的一维数字数组                                                                                  |
| `b`         | Array   | 样本b待计算的一维数字数组                                                                                  |
| `y`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |
| `iflast`    | bool    | 是否只返回最后一个数，默认为False                                                                          |

返回：Array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
a:=nDay3(50,stockZf3());
b:=nDay3(50,spec(stockZf3(),'SH000001'));
return a|b|ewmCorrel(a,b,10,1);
//结果
```

## `ewmCov(a, b, y, alphatype, adjust)`

指数加权移动协方差

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `a`         | array   | 样本a待计算的一维数字数组                                                                                  |
| `b`         | Array   | 样本b待计算的一维数字数组                                                                                  |
| `y`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
a:=nDay3(50,stockZf3());
b:=nDay3(50,spec(stockZf3(),'SH000001'));
return a|b|ewmCov(a,b,10,1);
//结果
```

## `ewmSlope(y, x, a, alphatype, adjust)`

指数加权移动回归斜率，y与x协方差/x方差（指数加权移动）

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `y`         | array   | 样本y待计算的一维数字数组                                                                                  |
| `x`         | array   | 样本x待计算的一维数字数组                                                                                  |
| `a`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
a:=nDay3(50,stockZf3());
b:=nDay3(50,spec(stockZf3(),'SH000001'));
return a|b|ewmSlope(a,b,10,1);
//结果
```

## `ewmIntercept(y, x, a, alphatype, adjust)`

指数加权移动回归截据项，y平均-斜率\*x平均 （指数加权移动）

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `y`         | array   | 样本y待计算的一维数字数组                                                                                  |
| `x`         | array   | 样本x待计算的一维数字数组                                                                                  |
| `a`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
a:=nDay3(50,stockZf3());
b:=nDay3(50,spec(stockZf3(),'SH000001'));
return a|b|ewmIntercept(a,b,10,1);
```

## `ewmResidual(y, x, a, alphatype, adjust)`

指数加权移动回归残差，y– (截距+斜率\*x)（指数加权移动）

| 参数        | 类型    | 说明                                                                                                       |
| ----------- | ------- | ---------------------------------------------------------------------------------------------------------- |
| `y`         | array   | 样本y待计算的一维数字数组                                                                                  |
| `x`         | array   | 样本x待计算的一维数字数组                                                                                  |
| `a`         | real    | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | Integer | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool    | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：array

### 示例

```tsl
sp_s(Pn_stock(),'SH000300');
sp_s(pn_date(),20190415T);
a:=nDay3(50,stockZf3());
b:=nDay3(50,spec(stockZf3(),'SH000001'));
return a|b|ewmResidual(a,b,10,1);
```

## `auc(x, y)`

计算auc，根据roc_curve计算出来的fpr和tpr序列值计算AUC值

| 参数 | 类型  | 说明    |
| ---- | ----- | ------- |
| `x`  | Array | x坐标点 |
| `y`  | Array | y坐标点 |

返回：real

### 示例

```tsl
y_true := array(1,1,2,2,1,2,1,2);
y_score := array(0.1,0.4,0.35,0.8,0.5,0.7,0.45,0.6);
ret := roc_curve(y_true,y_score,2);
fpr := ret[0];
tpr := ret[1];
return auc(fpr,tpr); //0.8125
```

## `MTMMa_v(n, m)`

动力指标MTM的移动平均MTMMa，与系统证券pn_stock()、系统时间pn_date()、系统周期pn_cycle()、复权方式pn_rate()和复权基准日pn_rateday()相关。调用时需注意设置系统参数。

| 参数 | 类型 | 说明             |
| ---- | ---- | ---------------- |
| `n`  | any  | 整数，交易日天数 |
| `m`  | any  | 整数，交易日天数 |

返回：float

## `MTM_v(n)`

动力指标MTM，计算当日收盘价C与N日前的收盘价Cn之差M，差值越来越大则意味着市势正加速上升，与系统证券pn_stock()、系统时间pn_date()、系统周期pn_cycle()、复权方式pn_rate()和复权基准日pn_rateday()相关。调用时需注意设置系统参数。

| 参数 | 类型 | 说明             |
| ---- | ---- | ---------------- |
| `n`  | any  | 整数，交易日天数 |

返回：float

## `ar_SubArray(stocks, rdate)`

字符串数组类型教学函数。返回字符串数组Stocks中每一只股票在指定报告期Rdate的十大股东情况。

| 参数     | 类型     | 说明           |
| -------- | -------- | -------------- |
| `stocks` | array    | 证券，股票代码 |
| `rdate`  | datetime | 报告期         |

返回：array

## `ar_Define1(_type)`

数组类型教学函数。跟据Type的值来返回相应的随机数组。

| 参数    | 类型 | 说明       |
| ------- | ---- | ---------- |
| `_type` | any  | 用户自定义 |

返回：array

## `ar_Define3()`

数组类型教学函数。创建一个10×10的二维随机数组，同时对列下标命名。

返回：array

## `Demo_mt_va_Cholesky()`

mt_va_Cholesky()函数教学函数。对指定对称正定矩阵的行列式值平方根，其中矩阵为array( (5.0,7.0,6.0,5.0),(7.0,12.0,8.0,7.0), (6.0,8.0,10.0,9.0),(5.0,7.0,9.0,10.0));。

返回：float

## `Demo_mt_iv_Gauss_Jordan()`

mt_iv_Gauss_Jordan()函数教学函数。求一般实矩阵的逆矩阵，其中求逆的矩阵A=array((0.2368,0.2471,0.2568,1.2671),(0.1968,0.2071,1.2168,0.2271),(0.1581,1.1675,0.1768,0.1871),(1.1161,0.1254,0.1397,0.149))。

返回：any

## `Demo_mt_Subtraction()`

mt_Subtraction()函数教学函数。矩阵减法，其中矩阵A=array((3,-3),(5,-5))，B=array((-2,4),(1,8))，返回A-B。

返回：any

## `Demo_mt_Addition()`

mt_Addition ()函数教学函数。矩阵加法，其中矩阵A=array((3,-3),(5,-5))，B=array((-2,4),(1,8))，返回A+B。

返回：any

## `Demo_mt_Transposition()`

mt_Transposition()函数教学函数。矩阵转置，返回转置后的矩阵，其中转置的矩阵A=array((3,-3,11),()5,-5,8)。

返回：any

## `Framedrop_duplicates(data, subset, keep, rowname)`

数据表-去重

| 参数      | 类型   | 说明                                                |
| --------- | ------ | --------------------------------------------------- |
| `data`    | array  | Table,二维数据表,源数据                             |
| `subset`  | string | String,去重字段                                     |
| `keep`    | string | String,去重保留方法，""f"":保留首个，""l"":保留最后 |
| `rowname` | string | String,保留原索引重置字段名                         |

返回：array

## `Framedrop_na(data, how, subset)`

数据表-去掉含Nan的行

| 参数     | 类型   | 说明                                                   |
| -------- | ------ | ------------------------------------------------------ |
| `data`   | array  | Table,二维数据表,源数据                                |
| `how`    | string | String,去na行方法，默认/1/""any"":任意，2/""all"":所有 |
| `subset` | string | String,去重字段                                        |

返回：array

## `framePivot_table(t, index, columns, vals, aggfunc, aggfuncnames)`

分组、透视、汇总，类似可见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

## `Framelag_zf(t, period, fillzero)`

数据表-推移涨幅(%) 涨幅(%)算法： 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

## `Framepct_change(t, period, fillzero)`

数据表-到当期的变动百分比(%) 变动百分比(%)算法 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

## `Frame_addprefix(t, prefix, ifcopy)`

数据表-数组下标批量加前缀 二维数组，对列名加前缀 一维数组，对行下标加前缀

| 参数     | 类型   | 说明                                   |
| -------- | ------ | -------------------------------------- |
| `t`      | any    | Table,源数组                           |
| `prefix` | string | String,前缀                            |
| `ifcopy` | bool   | Bool,是否在拷贝后的数组改列名,默认True |

返回：array

## `Frame_addsuffix(t, suffix, ifcopy)`

数据表-数组下标批量加后缀 二维数组，对列名加后缀 一维数组，对行下标加后缀

| 参数     | 类型   | 说明                                    |
| -------- | ------ | --------------------------------------- |
| `t`      | any    | Table,源数组                            |
| `suffix` | string | String,后缀                             |
| `ifcopy` | bool   | Bool,是否在拷贝后的数组改列名，默认True |

返回：array

## `chol(h, l, p, options, sneg)`

进行乔列斯基分解，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表示分解成功
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:rand: function:corr compile error or not found
// function:__main__:line 1:instruction:rand: function execute error
```

## `reIndex2(data, flag)`

修改数组的行标或列名，主要用于字符串下标修改为数字下标等

| 参数   | 类型             | 说明 |
| ------ | ---------------- | ---- |
| `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);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:reIndex2 compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

范例二：将行列标作为首列首行

```tsl
a := array('C': ('A': 1, 'B': 'too'), 'D': ('A': 2, 'B': 'two'));
return reIndex2(a, 5);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:reIndex2 compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `orth(a)`

矩阵范围内的标准正交基向量

| 参数 | 类型  | 说明   |
| ---- | ----- | ------ |
| `a`  | array | 数组， |

返回：array

#### 示例

```tsl
// 计算矩阵A的标准正交基
a := array((0, 1), (1, 1), (1, 0));
return orth(a);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:orth compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```

## `det(a)`

行列式

| 参数 | 类型  | 说明              |
| ---- | ----- | ----------------- |
| `a`  | array | 二维数字数组 样本 |

返回：real

#### 示例

```tsl
a := array((1, 2), (3, 4));
return det(a); // -2
```

## `isSymmetry(a, tol)`

判断是否为对称矩阵

| 参数  | 类型  | 说明           |
| ----- | ----- | -------------- |
| `a`   | array | array 二维数组 |
| `tol` | real  | real 精度      |

返回：integer

#### 示例

```tsl
a := array((2, 1), (1, 3));
return isSymmetry(a, 0.1); // 1
```

## `diag(a)`

对角阵

| 参数 | 类型  | 说明       |
| ---- | ----- | ---------- |
| `a`  | array | array 数组 |

返回：array

#### 示例

```tsl
a := array((2, 1), (1, 3));
return diag(a); // array(2,3);
```

## `norm2(a, flag)`

范数

| 参数   | 类型   | 说明              |
| ------ | ------ | ----------------- |
| `a`    | array  | 二维数字数组 样本 |
| `flag` | string | string 范数类型   |

返回：real

#### 示例

```tsl
a := array((2, 1), (1, 3));
return norm2(a, 'inf'); // 4
```

## `roots(p)`

一元n次方程求根

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `p`  | array | array 多项式 |

返回：array

#### 示例

```tsl
// 求根：3x^3+x^2+x^1+0^0=0
return roots(array(0, 1, 1, 3));
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:array: function:roots compile error or not found
// function:__main__:line 2:instruction:array: function execute error
```

## `cond(x)`

求矩阵 X 的条件数，最大奇异值除最小奇异值

| 参数 | 类型  | 说明                               |
| ---- | ----- | ---------------------------------- |
| `x`  | array | array 需要求条件数的矩阵或二维数组 |

返回：real

#### 示例

```tsl
x := array((9, 1), (-1, 0), (0, 2), (1, 1));
return cond(x); // 4.22
```

## `pinv(a, t)`

伪逆

| 参数 | 类型  | 说明                                    |
| ---- | ----- | --------------------------------------- |
| `a`  | array | array 矩阵                              |
| `t`  | real  | real 精度 默认为 2.220446049250313e-016 |

返回：array

#### 示例

```tsl
x := array((9, 1), (-1, 0), (0, 2), (1, 1));
return pinv(x);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:pinv compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `eigen(a, eigen, eigenvectors, isreal)`

特征根与特征向量

| 参数           | 类型    | 说明                              |
| -------------- | ------- | --------------------------------- |
| `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)
```

## `isDefinite(h)`

判断矩阵是否正定、半正定，采用 Cholesky 分解方法

| 参数 | 类型  | 说明       |
| ---- | ----- | ---------- |
| `h`  | array | array 样本 |

返回：real

#### 示例

```tsl
x := array((3, 1), (1, 4));
return isDefinite(x); // 1
```

## `transPose(data)`

数组转置。注意，该函数主要用于客户端结果处理，不提供给用户程序编辑。

| 参数   | 类型  | 说明                                                  |
| ------ | ----- | ----------------------------------------------------- |
| `data` | array | 数据表结构数据，第一列数据必须为字符串并且列数要大于3 |

返回：array

## `transPoseForChart(data)`

表格转置。注意，该函数主要用于客户端结果处理，不提供给用户程序编辑。

| 参数   | 类型  | 说明       |
| ------ | ----- | ---------- |
| `data` | array | 数据表类型 |

返回：array

## `transPoseForChartSysParam()`

表格转置。注意，该函数主要用于客户端结果处理，不提供给用户程序编辑。

返回：array

## `transPoseForChartSysParamEx()`

表格转置。注意，该函数主要用于客户端结果处理，不提供给用户程序编辑。

返回：array

## `transDataStandardize(nil_v)`

空(NIL)数据标准化。注意，该函数主要用于客户端结果处理，不提供给用户程序编辑。

| 参数    | 类型    | 说明                      |
| ------- | ------- | ------------------------- |
| `nil_v` | integer | Nil类型的数据标准化后的值 |

返回：array

## `mbbub(p, z)`

排序，对数组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);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:mbbub compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `componentScoreMatrix(cm, r)`

因子得分系数矩阵

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `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);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `factorScoreMatrix(cs, z)`

主因子得分

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `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);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `rotatedComponentMatrix(cm)`

返回方差最大正交旋转矩阵

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `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);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `princaipalComponentAnalysis(zt)`

主成分分析

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `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);
// 输出：
// Execute script error at Line:7
// function:__main__:line 7:instruction:usercall: function:princaipalComponentAnalysis compile error or not found
// function:__main__:line 7:instruction:usercall: function execute error
```

## `componentMatrix(eigen_value, eigen_vector, max_eigen_value)`

载荷矩阵

| 参数              | 类型  | 说明                                 |
| ----------------- | ----- | ------------------------------------ |
| `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);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `fScoreResult(factor_arr, max_eigen_value)`

获取主因子得分

| 参数              | 类型  | 说明                                 |
| ----------------- | ----- | ------------------------------------ |
| `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);
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `ar(y, p, approach)`

自回归模型，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');
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:usercall: function:randnorm compile error or not found
// function:__main__:line 1:instruction:usercall: function execute error
```

## `garchFit(model_spec, y, x, e0, s0, y0)`

广义自回归条件异方差模型，采用极大似然估计方法估计模型的参数

| 参数         | 类型  | 说明                                                   |
| ------------ | ----- | ------------------------------------------------------ |
| `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方差估计情况
```

## `wavedec(x, n, wname)`

使用给定的小波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
// 下面我们从图像来直接看看小波分解：
// 原始序列:
// 原始序列可分解成：
```

## `wrcoef(o, c, l, wname, n)`

一维离散小波单支重构，小波分析，小波重构中间函数或者细节系数（高频）提取

| 参数    | 类型    | 说明                                                          |
| ------- | ------- | ------------------------------------------------------------- |
| `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); // 第三次分解得到的高频
```

## `wavelet(s, wname, n, options)`

一维序列小波消噪

| 参数      | 类型    | 说明                                                          |
| --------- | ------- | ------------------------------------------------------------- |
| `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);
// 消噪和原始数据对比：
```

## `accumulativeYtMtoYtm(t, fname, dw)`

复合益率转日收益率。

| 参数    | 类型    | 说明                               |
| ------- | ------- | ---------------------------------- |
| `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;
// 输出：返回：
```

## `ytmToAccumulativeYtm(t, f_name, dw)`

日收益率转换复合收益率。

| 参数     | 类型    | 说明                               |
| -------- | ------- | ---------------------------------- |
| `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;
// 输出：
// Execute script error at Line:6
// function:__main__:line 6:instruction:usercall: function:ytmToAccumulativeYtm compile error or not found
// function:__main__:line 6:instruction:usercall: function execute error
```

## `ratioValue(v1, v2)`

比率（财务分析）

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回-1与-2的比率。
return ratioValue(-1, -2);
// 结果：-0.5
```

## `outPutValueByUnit(data_type, data_unit)`

单位转换。

| 参数        | 类型   | 说明             |
| ----------- | ------ | ---------------- |
| `data_type` | string | 字符串，数据类型 |
| `data_unit` | real   | 实型，指定单位   |

返回：real

### 示例

```tsl
// 返回1234.5以10为单位转换后的结果
return outPutValueByUnit(1234.5, 'Real', 10);
// 结果：123.45
```

## `outPutLnGrowRatio(v1, v2)`

对数增长率输出(%)。

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 取3与4的对数增长率
return outPutLnGrowRatio(3, 4);
// 结果：-28.77
```

## `outPutGrowValue(v1, v2)`

增长

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回13与14的差值
return outPutGrowValue(13, 14);
// 结果：-1
```

## `multyValue(v1, v2)`

乘法（财务分析）

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回取-3与-5的乘积。
return multyValue(-3, -5);
// 结果：-15
```

## `outPutGrowValue3(v1, v2)`

增长

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回13与14的差值
return outPutGrowValue3(13, 14);
// 结果：-1
```

## `outPutGrowRatio3(v1, v2)`

增长率(%)

| 参数 | 类型 | 说明         |
| ---- | ---- | ------------ |
| `v1` | real | 实型，期末值 |
| `v2` | real | 实型，期初值 |

返回：real

### 示例

```tsl
// 返回14到13的增长率(%)
return outPutGrowRatio3(14, 13);
// 结果：7.69
```

## `SelectStockIndex_Call(stock_arr, beg_t, end_t, select_cond, not_is_sell, sell_cond, not_need_stoped)`

返回选股结果

| 参数              | 类型     | 说明                     |
| ----------------- | -------- | ------------------------ |
| `stock_arr`       | array    | 一维字符串数组，证券代码 |
| `beg_t`           | datetime | 日期型时间，开始选股时间 |
| `end_t`           | datetime | 日期型时间，结束选股时间 |
| `select_cond`     | any      | 布尔表达式，选股条件     |
| `not_is_sell`     | bool     | object                   |
| `sell_cond`       | any      | 布尔表达式，卖出股票条件 |
| `not_need_stoped` | bool     | object                   |

返回：array

## `Demo_ip_Hermite_B()`

ip_Hermite_B()函数教学函数。埃尔米特等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_SLG()`

ip_SLG()函数教学函数。二元全曲间插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_SLQ()`

ip_SLQ()函数教学函数。二元三点插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Aitken_A()`

ip_Aitken_A()函数教学函数。埃特金不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Hermite_A()`

ip_Hermite_A()函数教学函数。埃儿米特不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Parabola_A()`

ip_Parabola_A()函数教学函数。抛物线不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Lagrangian_A()`

ip_Lagrangian_A()函数教学函数。拉格朗日不等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Spline_A()`

ip_Spline_A ()函数教学函数。第一类边界条件的三次样条插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Aitken_B()`

ip_Aitken_B()函数教学函数。埃特金等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Lagrangian_B()`

ip_Lagrangian_B()函数教学函数。拉格朗日等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Spline_B()`

ip_Spline_B ()函数教学函数。第二类边界条件的三次样条插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Parabola_B()`

ip_Parabola_B ()函数教学函数。抛物线等距插值，计算给定插值点处的函数值。

返回：float

## `Demo_ip_Spline_C()`

ip_Spline_C ()函数教学函数。第三类边界条件的三次样条插值，计算给定插值点处的函数值。

返回：float

## `Demo_ig_Simpson_1()`

ig_Simpson_1()函数教学函数。辛普森求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Romberg()`

ig_Romberg()函数教学函数。龙贝格求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Simpson_2()`

ig_Simpson_2()函数教学函数。辛普森二重积分法回调函数，计算定积分。

返回：float

## `Demo_ig_Trapezoid_2()`

Demo_ig_Trapezoid_2()函数教学函数。自适应梯形求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Chebyshev()`

Demo_ig_Chebyshev()函数教学函数。切比雪夫求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Gauss()`

Demo_ig_Gauss()函数教学函数。高斯求积法回调函数，计算定积分。

返回：float

## `Demo_ig_Trapezoid_1()`

Demo_ig_Trapezoid_1()函数教学函数。变步长梯形求积法回调函数，计算定积分。

返回：float

## `ig_Trapezoid_2CallBack(x)`

自适应梯形求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_Trapezoid_1CallBack(x)`

变步长梯形求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_Simpson_2CallBack2(x)`

辛普森二重积分法积分上限回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_Simpson_1CallBack(x)`

辛普森求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_Simpson_2CallBack1(x)`

辛普森二重积分法积分下限回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_ChebyshevCallBack(x)`

切比雪夫求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_RombergCallBack(x)`

龙贝格求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_GaussCallBack(x)`

高斯求积法回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |

返回：float

## `ig_Simpson_2CallBack(x, y)`

辛普森二重积分法函数值回调函数。关于自变量x的函数式，一般作用于定积分计算的被积函数。

| 参数 | 类型  | 说明 |
| ---- | ----- | ---- |
| `x`  | float | 实数 |
| `y`  | float | 实数 |

返回：float

## `Demo_se_Gauss_Jordan()`

se_Gauss_Jordan()函数教学函数。高斯-约当消去法，用全主元高斯-约当法消去法同时求解系数矩阵相同而常数向量不同的m个n阶线性方程组AX = B，其中A=array((0.2368,0.2471,0.2568,1.2671),(0.1968,0.2071,1.2168,0.2271),(0.1581,1.1675,0.1768,0.1871), (1.1161,0.1254,0.1397,0.1490))，B=array((1.8471),(1.7471),(1.6471),(1.5471))。

返回：any

## `Demo_se_Ldl()`

se_Ldl()函数教学函数。LU分解法，用LU分解法求解系数矩阵为对称、右端具有m组常数向量的线性方程组 AX =B,其A=array((5,7,6,5,1),(7,10,8,7,2),(5,7,9,10,4),(1,2,3,4,5)),B=array((24,96),(34,136),(36,144),(35,140),(15,60));

返回：any

## `Demo_se_Gauss()`

se_Gauss()函数教学函数。高斯消去法，用全选主元高斯消去法求解n阶线性方程组AX = B。其中A=array((0.2368,0.2471,0.2568,1.2671),(0.1968,0.2071,1.2168,0.2271),(0.1581,1.1675,0.1768,0.1871),(1.1161,0.1254,0.1397,0.1490))，B= array(1.8471,1.7471,1.6471,1.5471)

返回：any

## `Demo_se_Gauss_Seidel()`

se_Gauss_Seidel()函数教学函数。高斯-赛德尔迭代法，用高斯-赛德尔迭代法求解系数矩阵具有主元占优的线性方程组AX = B。其中A=array((7,2,1,-2), (9,15,3,-2),(-2,-2,11,5),(1,3,2,13))，B=array(4,7,-1,0)。

返回：any

## `Demo_se_Cholesky()`

se_Cholesky()函数教学函数。乔列斯基分解法，用乔列斯基(Cholesky)分解法(即平方根法)求解系数矩阵为对称正定、且右端具有m组常数向量的线性方程组AX = B。其中A=array((5,7,6,5),(7,10,8,7),(6,8,10,9),(5,7,9,10))，B= array((23,92),(32,128), (33,132), (31,124))。

返回：any

## `nchoosek(n, k)`

样本组合

| 参数 | 类型    | 说明               |
| ---- | ------- | ------------------ |
| `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"))
```

## `betainc(x, a, b, tail)`

不完全贝塔函数

| 参数   | 类型   | 说明                                  |
| ------ | ------ | ------------------------------------- |
| `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));
// 输出：
// Execute script error at Line:5
// function:__main__:line 5:instruction:usercall: function:betainc compile error or not found
// function:__main__:line 5:instruction:usercall: function execute error
```

## `percentileOfScore(data, score, _type)`

百分位占比(%)

| 参数    | 类型    | 说明             |
| ------- | ------- | ---------------- |
| `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;
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `interp(x, y, xi, method)`

分段插值函数，根据给定的数据 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)
```

## `spline(x1, y1, xx1)`

三次样条插值

| 参数  | 类型  | 说明                    |
| ----- | ----- | ----------------------- |
| `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)
```

## `integral(call_back, a, b, method)`

求函数的数值积分

| 参数        | 类型   | 说明                 |
| ----------- | ------ | -------------------- |
| `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
```

## `hessian(fun, x)`

海塞矩阵 求解函数 fun 在x点的 海塞矩阵；

| 参数  | 类型   | 说明             |
| ----- | ------ | ---------------- |
| `fun` | string | 字符串，函数名   |
| `x`   | array  | 一维数组，指定点 |

返回：array

### 示例

```tsl
return hessian("Hessian.demo", array(3, 4));
```

## `perms(x)`

样本排列

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `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);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:perms compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

范例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
// 输出：
// Execute script error at Line:0
```

## `maxDrawDown(data, updn, interval, ifabs)`

最大回撤

| 参数       | 类型    | 说明                                            |
| ---------- | ------- | ----------------------------------------------- |
| `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即可。
```

## `minRecoveryTime(r, n1, n2)`

最小恢复时间

| 参数 | 类型    | 说明                 |
| ---- | ------- | -------------------- |
| `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
```

## `generateCombinations(list, ret, start, n)`

非空全组合生成器

| 参数    | 类型    | 说明                        |
| ------- | ------- | --------------------------- |
| `list`  | array   | 一维数组 样本,              |
| `ret`   | array   | 返回生成的组合数组,         |
| `start` | integer | Int 选取起始数据的位置,     |
| `n`     | integer | Int 记录每组数据的起始位置, |

返回：integer

### 示例

```tsl
list := array('a', 'b', 'c');
generateCombinations(list, ret);
return ret;
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:generateCombinations compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `percentage(y, per, style)`

百分位去极值

| 参数    | 类型        | 说明                                                                                        |
| ------- | ----------- | ------------------------------------------------------------------------------------------- |
| `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);
```

## `GM_Initial(x, method, un)`

数据初始化，提供了几种数据变换的方法，有初值化、均值化、最小值化、最大值化、按行区间值化、按列区间值化、归一化、逆化、倒数化和始点零化处理原始的序列 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_Corr(x, l)`

灰色关联度，以l行为参考数列的灰色关联度，返回的是关联度矩阵 ，， 以为参考数列，则关联度计算步骤如下： 1）初值化：； 2）求差数列：， 3）求两级最大和最小：， 4）求关联系数：，为分辨系数，是0到1之间的数 5）求关联度：

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `x`  | array | 数据矩阵，为二维数组类型； |
| `l`  | any   | 参考序列标号，为整数类型   |

返回：array

## `GM_AGO(x, method, r)`

数列生成，r(r>0)次的累加或累减生成新数列 1）累加：， 2）累减：，

| 参数     | 类型   | 说明                              |
| -------- | ------ | --------------------------------- |
| `x`      | array  | 数据矩阵，为一维数组类型；        |
| `method` | string | 生成方法(add,sub)，为字符串类型； |
| `r`      | any    | 次数，为整数类型                  |

返回：array

## `GM_Scorr(x, method)`

灰色绝对关联度、灰色相对关联度和灰色综合关联度，返回的是关联度矩阵 ，， 1）灰色绝对关联度： 2）灰色相对关联度：先对数列进行初值化，然后求新数列的灰色绝对关联度，即为原数列的灰色相对关联度 3）灰色综合关联度：

| 参数     | 类型   | 说明                              |
| -------- | ------ | --------------------------------- |
| `x`      | array  | 数据矩阵，为二维数组类型；        |
| `method` | string | 方法(abs,ret,com)，为字符串类型； |

返回：array

## `GM_Estimate(x, l)`

GM(1,1)模型，用于灰色系统模型的l步预测 结果说明： 平均相对误差：越小越接近零越好； 关联度：当ρ=0.5时，关联度大于0.6便满意 方差比：C 小误差概率：P

| 参数 | 类型  | 说明                       |
| ---- | ----- | -------------------------- |
| `x`  | array | 数据矩阵，为一维数组类型； |
| `l`  | any   | 预测步长，为整数类型       |

返回：array

## `Prog_L(f, a, b, aeq, beq, lb, ub, x0, options, ozarr, intarr)`

使用单纯形法，和起作用集法，系统默认作用集形法求解线性规划问题，即求解目标都为线性和约束条件都为线性的规划问题 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_N(fun, x0, a, b, aeq, beq, lb, ub, nlc, options)`

采用拟牛顿下山方法求解非线性规划求解。 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_M(fun, x0, goal, weight, a, b, aeq, beq, lb, ub, nlc, options)`

求解多目标规划问题 模型表达： 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

## `NonLP_Fminsearch(fun, x0, methods)`

无约束最小值求解,求解模型如下： min fun(x)

| 参数      | 类型   | 说明                                                                       |
| --------- | ------ | -------------------------------------------------------------------------- |
| `fun`     | string | 目标函数，函数名字符串                                                     |
| `x0`      | array  | 初始值，一维数字数组                                                       |
| `methods` | any    | 方法选择0 单纯形法1 转轴法2 模式搜索法3 拟牛顿下山法（默认方法，推荐使用） |

返回：array

## `NonLP_minSUMT(fun, x0, a, b, aeq, beq, nonlcon, methods)`

（非线性规划建议统一使用prog_n函数）混合惩罚函数+转轴法/模式搜索法：可解所有优化问题，返回最优点、最优值和迭代次数。可求解如下问题：

| 参数      | 类型   | 说明                                   |
| --------- | ------ | -------------------------------------- |
| `fun`     | string | 目标函数表达式，为字符串类型；         |
| `x0`      | array  | 初值向量，为一维数组类型；             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型； |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；     |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型；   |
| `nonlcon` | string | 非线性约束回调，为字符串类型；         |
| `methods` | string | 方法选择,’NM’,’Rb’,’HJ’                |

返回：array

## `NonLP_minPS(fun, x0, a, b, nonlcon)`

（非线性规划建议统一使用prog_n函数）,坐标轮换法求不等式约束问题，初值必须在可行域内！可求解如下问题：

| 参数      | 类型   | 说明                                   |
| --------- | ------ | -------------------------------------- |
| `fun`     | string | 目标函数表达式，为字符串类型；         |
| `x0`      | array  | 初值向量，为一维数组类型；             |
| `a`       | array  | 线性矩阵不等式约束，为二维数组类型；   |
| `b`       | array  | 线性向量不等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；         |

返回：array

## `NonLP_minFactor(fun, x0, aeq, beq, nonlcon)`

（非线性规划建议统一使用prog_n函数）,乘子法求等式约束问题，可求解如下问题：

| 参数      | 类型   | 说明                                 |
| --------- | ------ | ------------------------------------ |
| `fun`     | string | 目标函数表达式，为字符串类型；       |
| `x0`      | array  | 初值向量，为一维数组类型；           |
| `aeq`     | array  | 线性矩阵等式约束，为二维数组类型；   |
| `beq`     | array  | 线性向量等式约束值，为一维数组类型； |
| `nonlcon` | string | 非线性约束回调，为字符串类型；       |

返回：array

## `NonLP_Fmincon(fun, x0, a, b, aeq, beq, nonlcon, c, methods)`

（非线性规划建议统一使用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_Range(fun, x0, h)`

进退法，可一维优化问题的确定搜索区间，但目标函数必须是单峰函数，返回结果为上下界的取值。（中间函数）

| 参数  | 类型   | 说明                         |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0`  | float  | 初值，为实数类型；           |
| `h`   | float  | 步长，为实数类型；           |

返回：array

## `NonLP_BSearch(fun, x0, h)`

一维盲人搜索方法，目标函数既可以是单峰，也可以是多峰。返回最优点和最优值。（中间函数）

| 参数  | 类型   | 说明                         |
| ----- | ------ | ---------------------------- |
| `fun` | string | 目标函数表达式，为字符串类型 |
| `x0`  | float  | 初值，为实数类型；           |
| `h`   | float  | 步长，为实数类型；           |

返回：array

## `NonLP_Golden(fun, a, b)`

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割法搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型           |

返回：array

## `NonLP_Fibonacci(fun, a, b)`

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），斐波那契法，用斐波那契数列去搜索\[a,b\]区间内目标函数的最小值，返回最优点和最优值

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型           |

返回：array

## `NonLP_GP(fun, a, b)`

（一维最小值搜索建议统一使用NonLP_Fminbnd函数），黄金分割+抛物线插值法：一维优化方法，返回最优点和最优值

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `a`   | float  | 区间左侧，为实数类型；         |
| `b`   | float  | 区间右侧，为实数类型；         |

返回：array

## `NonLP_Nelder(fun, x0)`

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）内德-米德法，无约束多维的非线性规划方法，即单纯形法。返回最优点和最优值。

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `NonLP_Hooke_Jeeves(fun, x0)`

（无约束最小值求解建议统一使用NonLP_Fminsearch函数）模式搜索法，又叫Hooke-Jeeves法，求解无约束多维极值问题，返回最优点和最优值。

| 参数  | 类型   | 说明                           |
| ----- | ------ | ------------------------------ |
| `fun` | string | 目标函数表达式，为字符串类型； |
| `x0`  | array  | 初值向量，为一维数组类型       |

返回：array

## `linearProgramming(f, a, b, aeq, beq)`

（线性规划，包括整数规划，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
```

## `intLinProg(f, a, b, aeq, beq, int_par)`

（线性规划，包括整数规划，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
```

## `quadprog(h, f, a, b, aeq, beq)`

（二次规划建议统一使用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)`

（二次规划建议统一使用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
```

## `quadLagR(h, f, aeq, beq)`

(二次规划建议统一使用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
```

## `Hooke_Jeeves_Method(x0, d0, d_min, r, call_back)`

H-J法求解无约束最优化问题

| 参数        | 类型   | 说明                         |
| ----------- | ------ | ---------------------------- |
| `x0`        | array  | 一维数字数组类型             |
| `d0`        | array  | 一维数字数组类型             |
| `d_min`     | array  | 一维数字数组类型             |
| `r`         | float  | 实数类型                     |
| `call_back` | string | 字符串类型，计算目标值的回调 |

返回：array

## `SUMT_Method(x0, call_back)`

SUMT法求解有约束最优化问题

| 参数        | 类型   | 说明                               |
| ----------- | ------ | ---------------------------------- |
| `x0`        | array  | 一维数字数组类型，各个变量的初始值 |
| `call_back` | string | 字符串类型，计算目标值的回调       |

返回：array

## `Sumt_Method__Pgm()`

Sumt算法测试

返回：array

## `Sumt_Method_CallBack(x, r)`

Sumt算法回调

| 参数 | 类型  | 说明             |
| ---- | ----- | ---------------- |
| `x`  | array | 一维数字数组类型 |
| `r`  | float | 实数类型         |

返回：float

## `PD_PreTaxPriceField()`

分红送-派息(税前)。根据不同的数据库提供商返回对应的值

返回：string

## `PD_NoticeDateField()`

分红送-权息公告日字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_PriceAmountField()`

红利金额

返回：string

## `PD_EXDateField()`

分红送-除权除息日字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_IssureYearField()`

分红送-分配年度字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_DominatorValue()`

分红送-送股比例分母。根据不同的数据库提供商返回对应的值

返回：any

## `PD_GivenSharesField()`

分红送-送股数量字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_RecordDateField()`

分红送-股权登记日字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_AdvanceDateField()`

分红送-预案公告日字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_AllRatioField()`

分红送-送股比。根据不同的数据库提供商返回对应的值

返回：string

## `PD_FirstTradingDateField()`

分红送-送股上市日。根据不同的数据库提供商返回对应的值

返回：string

## `PD_GivenRatioField()`

分红送-红股比字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_DistributeYearField()`

分红送-分配年度字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_AddRatioField()`

分红送-转增比字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_BonusListDateField()`

分红送-分红发放日。根据不同的数据库提供商返回对应的值

返回：string

## `PD_DecisionDeclareDateField()`

分红送-决案公告日字段。根据不同的数据库提供商返回对应的值

返回：string

## `PD_AfterTaxPriceField()`

分红送-派息(税后)。根据不同的数据库提供商返回对应的值

返回：string

## `PD_RatioField()`

分红送-比例字段。根据不同的数据库提供商返回对应的值

返回：string

## `SD_EndDateField()`

配股-缴款截止日。根据不同的数据库提供商返回对应的值

返回：string

## `SD_RatioField()`

配股-配股比。根据不同的数据库提供商返回对应的值

返回：string

## `SD_PriceField()`

配股-配股价。根据不同的数据库提供商返回对应的值

返回：string

## `SD_RecordDateField()`

配股-股权登记日。根据不同的数据库提供商返回对应的值

返回：string

## `SD_ValueOfRightsField()`

配股-募集资金总额。根据不同的数据库提供商返回对应的值

返回：string

## `SD_TrueVolField()`

配股-实际配股数。根据不同的数据库提供商返回对应的值

返回：string

## `SD_ActualValueOfRightsField()`

配股-募集资金净额。根据不同的数据库提供商返回对应的值

返回：string

## `SD_FirstTradingDateField()`

配股-配股上市日。根据不同的数据库提供商返回对应的值

返回：string

## `SD_DistributeYearField()`

配股-分配年度。根据不同的数据库提供商返回对应的值

返回：string

## `SD_AdvanceDateField()`

配股-预案公布日。根据不同的数据库提供商返回对应的值

返回：string

## `SD_ActualRatioField()`

配股-实配比。根据不同的数据库提供商返回对应的值

返回：string

## `SD_BeginDateField()`

配股-缴款起始日。根据不同的数据库提供商返回对应的值

返回：string

## `SD_DecisionDeclareDateField()`

配股-决议公布日。根据不同的数据库提供商返回对应的值

返回：string

## `SD_DeclareDateField()`

配股-说明书刊登日字段。根据不同的数据库提供商返回对应的值

返回：string

## `SD_PriceCeilingField()`

配股-配股价上限。根据不同的数据库提供商返回对应的值

返回：string

## `SD_DominatorValue2()`

配股-配股金额单位。根据不同的数据库提供商返回对应的值

返回：any

## `SD_PriceFloorField()`

配股-配股价下限。根据不同的数据库提供商返回对应的值

返回：string

## `SD_DominatorValue()`

配股-配股比例分母。根据不同的数据库提供商返回对应的值

返回：any

## `SD_EXDateField()`

配股-除权日。根据不同的数据库提供商返回对应的值

返回：string

## `sf_Normal2_(x)`

累积标准正态分布，等同于sf_normcdf(x,0,1)

| 参数 | 类型  | 说明           |
| ---- | ----- | -------------- |
| `x`  | float | 实数，随机变量 |

返回：float

## `WeightedVariance_freq(x, w, v1)`

频率权重加权样本方差 频率权重下，权重表示样本出现的次数 其中表示样本总数，当为样本个数时，，为加权均值。

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | array | 一维数字数组 |
| `w`  | array | 一维权重向量 |
| `v1` | any   | 样本个数     |

返回：float

## `WeightedCov_freq(a, b, w, v1)`

频率权重加权样本协方差 其中：分别表示加权均值，表示样本总数，当为样本个数时，

| 参数 | 类型  | 说明                            |
| ---- | ----- | ------------------------------- |
| `a`  | array | 样本a计算移动平均的一维数字数组 |
| `b`  | array | 因子b计算移动平均的一维数字数组 |
| `w`  | array | 一维权重向量                    |
| `v1` | any   | 样本个数                        |

返回：any

## `WeightedCovariance_freq(a, w, v1)`

频率权重加权样本协方差矩阵

| 参数 | 类型  | 说明                           |
| ---- | ----- | ------------------------------ |
| `a`  | array | 待计算的矩阵，每一列为一个因子 |
| `w`  | array | 一维权重向量                   |
| `v1` | any   | 样本个数                       |

返回：array

## `WeightedSkewness_freq(x, w, v1)`

频率权重加权样本偏度 根据 V1^2/\[(V1-1)\*(V1-2)\]进行修正

| 参数 | 类型  | 说明                   |
| ---- | ----- | ---------------------- |
| `x`  | array | 一维数字数组，样本序列 |
| `w`  | array | 一维数字数组，权重向量 |
| `v1` | any   | 整数，样本总数         |

返回：float

## `WeightedKurtosis_freq(x, w, v1)`

频率权重加权样本峰度 根据V1^2\*(V1+1)/\[(V1-1)\*(V1-2)\*(V1-3)\]进行修正

| 参数 | 类型  | 说明                   |
| ---- | ----- | ---------------------- |
| `x`  | array | 一维数字数组，样本序列 |
| `w`  | array | 一维数字数组，权重向量 |
| `v1` | any   | 整数，样本总数         |

返回：float

## `CorrelM_ewm(a, b, alphatype, adjust)`

指数加权下最后一期的相关系数矩阵

| 参数        | 类型  | 说明                                                                                                       |
| ----------- | ----- | ---------------------------------------------------------------------------------------------------------- |
| `a`         | array | 待计算的矩阵，每一列表示一个因子                                                                           |
| `b`         | float | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                         |
| `alphatype` | any   | 用户自定义，默认为0                                                                                        |
| `adjust`    | bool  | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。 |

返回：array

## `Covariance_ewm(a, b, alphatype, adjust)`

指数加权下最后一期的协方差矩阵

| 参数        | 类型  | 说明                                                                                                                                                                                                      |
| ----------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `a`         | array | 待计算的矩阵，每一列表示一个因子                                                                                                                                                                          |
| `b`         | float | 衰减因子，与alphatype共同决定实际的衰减因子alpha，见平滑系数的确定                                                                                                                                        |
| `alphatype` | any   | 用户自定义，默认为0                                                                                                                                                                                       |
| `adjust`    | bool  | 是否调整，True、实际权重计算，False、根据无穷序列假设下的递推式计算，默认为False，见指数加权的两种递推式。；biased:是否有偏，True、返回加权总体方差，False、返回以修正后的无偏的加权样本方差，默认为Fasle |

返回：array

## `Accuracy_Score(y_true, y_pred, normalize, sample_weight)`

计算准确率

| 参数            | 类型  | 说明                                                            |
| --------------- | ----- | --------------------------------------------------------------- |
| `y_true`        | array | 数组，真实值序列                                                |
| `y_pred`        | array | 数组，预测值序列                                                |
| `normalize`     | bool  | 布尔型，是否转为准确率，默认为真；为假时返回 两个序列相等的个数 |
| `sample_weight` | array | 数组，样本权重                                                  |

返回：float

## `confusion_matrix(y_true, y_pred, labels, sample_weight)`

计算混淆矩阵

| 参数            | 类型  | 说明                                                             |
| --------------- | ----- | ---------------------------------------------------------------- |
| `y_true`        | array | 真实值序列                                                       |
| `y_pred`        | array | 预测值序列                                                       |
| `labels`        | array | 混淆矩阵下标排序，不给定labels时，可以通过labels读取出。内部排序 |
| `sample_weight` | array | 样本权重，1表示等权重，与全一数组等效，默认等权重                |

返回：array

## `confusion_matrix2(y_true, y_pred, labels, sample_weight)`

计算混淆矩阵，返回以分类标签为下标的混淆矩阵

| 参数            | 类型  | 说明                                                               |
| --------------- | ----- | ------------------------------------------------------------------ |
| `y_true`        | array | 真实值序列                                                         |
| `y_pred`        | array | 预测值序列                                                         |
| `labels`        | array | 混淆矩阵下标排序，；不给定labels时，可以通过labels读取出；内部排序 |
| `sample_weight` | array | 样本权重，1表示等权重，与全一数组等效，默认等权重                  |

返回：array

## `multilabel_confusion_matrix(y_true, y_pred, labels, sample_weight, samplewise)`

多标签混淆矩阵，适用于单标签和多标签。本函数支持多标签分类，单标签分类， 但在计算单标签分类的混淆矩阵的时候，跟confusion_matrix是不一样的

| 参数            | 类型  | 说明                                               |
| --------------- | ----- | -------------------------------------------------- |
| `y_true`        | array | 真实值标签，一维或者二维数组                       |
| `y_pred`        | array | 预测值标签 ，与y_true统一大小                      |
| `labels`        | array | 要计算的标签集合，默认全部计算                     |
| `sample_weight` | array | 样本权重                                           |
| `samplewise`    | bool  | 布尔值，表示是否按样本统计混淆矩阵，只适用于多标签 |

返回：array

## `Hamming_loss(y_true, y_pred, sample_weight)`

计算分类模型的汉明损失，适用于单标签和多标签模型，其中多标签模型数据是多维二元标签

| 参数            | 类型  | 说明                                                         |
| --------------- | ----- | ------------------------------------------------------------ |
| `y_true`        | array | 一维或者二维数组，真实类别，长度与样本数相等                 |
| `y_pred`        | array | 一维或者二维数组（与y_true一样），预测类别，长度与样本数相等 |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重                             |

返回：float

## `matthews_corrcoef(y_true, y_pred, sample_weight)`

用以测量分类模型的分类性能的指标，该指标考虑了真阳性、真阴性和假阳性和假阴性，通常认为该指标是一个比较均衡的指标，适用于单标签二分类和多分类

| 参数            | 类型  | 说明                             |
| --------------- | ----- | -------------------------------- |
| `y_true`        | array | 一维数组，真实标签               |
| `y_pred`        | array | 一维数组，预测标签               |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重 |

返回：float

## `cohen_kappa_score(y1, y2, labels, weights, sample_weight)`

衡量单标签分类模型的分类精度的kappa系数，适用于单标签二分类和多分类

| 参数            | 类型   | 说明                                                                       |
| --------------- | ------ | -------------------------------------------------------------------------- |
| `y1`            | array  | 一维数组，真实标签                                                         |
| `y2`            | array  | 一维数组，预测标签，y1和y2交换顺序不影响计算结果                           |
| `labels`        | array  | 一维数组，选择的标签集，默认是y1和y2出现过的标签                           |
| `weights`       | string | 字符串，kappa系数的惩罚权重，可选array(nil,'linear','quadratic');默认是nil |
| `sample_weight` | array  | 一维数组，样本权重，默认是等权重，全一数组                                 |

返回：float

## `balanced_accuracy_score(y_true, y_pred, sample_weight, adjusted)`

计算单标签分类模型的平衡准确率，适用于单标签模型

| 参数            | 类型  | 说明                                                      |
| --------------- | ----- | --------------------------------------------------------- |
| `y_true`        | array | 一维数组，真实标签                                        |
| `y_pred`        | array | 一维数组，预测标签                                        |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重                          |
| `adjusted`      | bool  | 布尔值，是否调整准确率，去掉随机部分，默认false，不作调整 |

返回：float

## `precision_score(y_true, y_pred, average, labels, pos_label, sample_weight)`

计算precision，适用于单标签和多标签分类

| 参数            | 类型   | 说明                                                                                                                                                       |
| --------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y_true`        | array  | 真实标签                                                                                                                                                   |
| `y_pred`        | array  | 预测标签                                                                                                                                                   |
| `average`       | string | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，计算每一个标签的precision |
| `labels`        | array  | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                             |
| `pos_label`     | any    | 正例标签，在单标签二分类时起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略                                                |
| `sample_weight` | array  | 样本权重，默认等权重                                                                                                                                       |

返回：float

## `Log_loss(y_true, y_pred_pro, sample_weight)`

计算分类模型的对数损失，适用于概率估计模型，即通过输出概率来确定类别的模型，只适用于 单标签分类

| 参数            | 类型  | 说明                                                                                                                        |
| --------------- | ----- | --------------------------------------------------------------------------------------------------------------------------- |
| `y_true`        | array | 一维数组，真实类别，长度与样本数相等                                                                                        |
| `y_pred_pro`    | array | 二维数组，样本属于各个类别的输出概率；lablels :一维数组，样本可以取到的类别标签，；不提供则默认是y_true出现过的标签求唯一值 |
| `sample_weight` | array | 一维数组，样本权重，默认是等权重                                                                                            |

返回：float

## `recall_score(y_true, y_pred, average, labels, pos_label, sample_weight)`

计算recall，适用于单标签和多标签分类

| 参数            | 类型   | 说明                                                                                                                                                       |
| --------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y_true`        | array  | 真实标签                                                                                                                                                   |
| `y_pred`        | array  | 预测标签                                                                                                                                                   |
| `average`       | string | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，计算每一个标签的precision |
| `labels`        | array  | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                             |
| `pos_label`     | any    | 正例标签，在单标签二分类时起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略                                                |
| `sample_weight` | array  | 样本权重，默认等权重                                                                                                                                       |

返回：float

## `fbeta_score(y_true, y_pred, beta, average, labels, pos_label, sample_weight)`

计算f_score，适用于单标签和多标签分类

| 参数            | 类型   | 说明                                                                                                                                                         |
| --------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `y_true`        | array  | 真实标签                                                                                                                                                     |
| `y_pred`        | array  | 预测标签                                                                                                                                                     |
| `beta`          | float  | beta参数，默认是1                                                                                                                                            |
| `average`       | string | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，；计算每一个标签的precision |
| `labels`        | array  | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                               |
| `pos_label`     | any    | 正例标签，在单标签二分类时起作用，；当数据是单标签二分类时，并且average等于"binary"时有用，其他情况会被忽略                                                  |
| `sample_weight` | array  | 样本权重，默认等权重                                                                                                                                         |

返回：float

## `f1_score(y_true, y_pred, average, labels, pos_label, sample_weight)`

调用fbeta_score时beta固定为1，适用于单标签和多标签分类

| 参数            | 类型   | 说明                                                                                                                                                         |
| --------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `y_true`        | array  | 真实标签                                                                                                                                                     |
| `y_pred`        | array  | 预测标签                                                                                                                                                     |
| `average`       | string | 平均方法，可选array(nil,'micro', 'macro', 'weighted', 'samples','binary')，；'samples'只适用于多标签，默认是nil，即不做平均处理，；计算每一个标签的precision |
| `labels`        | array  | 需要计算的标签，默认是y_true和y_pred出现的所有                                                                                                               |
| `pos_label`     | any    | 正例标签，在单标签二分类是起作用，当数据是单标签二分类时，；并且average等于"binary"时有用，其他情况会被忽略                                                  |
| `sample_weight` | array  | 样本权重，默认等权重                                                                                                                                         |

返回：float

## `precision_recall_curve(y_true, y_score, pos_label, sample_weight)`

计算PRC曲线序列值，适用于单标签二分类和多分类

| 参数            | 类型  | 说明                              |
| --------------- | ----- | --------------------------------- |
| `y_true`        | array | 真实标签                          |
| `y_score`       | array | 预测输出概率                      |
| `pos_label`     | any   | 正例标签，默认是1，多分类必须提供 |
| `sample_weight` | array | 样本权重，默认等权重              |

返回：array

## `ks_curve(y_true, y_score, pos_label, sample_weight, drop_intermediate)`

计算K-S曲线序列值，使用单标签二分类和多分类

| 参数                | 类型  | 说明                              |
| ------------------- | ----- | --------------------------------- |
| `y_true`            | array | 真实标签                          |
| `y_score`           | array | 预测输出概率                      |
| `pos_label`         | any   | 正例标签，默认是1，多分类必须提供 |
| `sample_weight`     | array | 样本权重，默认等权重              |
| `drop_intermediate` | bool  | 是否去掉无用点，默认为真          |

返回：array

## `max_error(y_true, y_pred, sample_weight)`

在完全拟合的单输出回归模型中，训练集上的max_error将为0。

| 参数            | 类型 | 说明         |
| --------------- | ---- | ------------ |
| `y_true`        | any  | 数据的实际值 |
| `y_pred`        | any  | 模型的预测值 |
| `sample_weight` | any  | 样本权重     |

返回：float

## `mean_absolute_error(y_true, y_pred, sample_weight, multioutput)`

暂时参数multioutput定义：为空数组，供后续开发使用。

| 参数            | 类型 | 说明           |
| --------------- | ---- | -------------- |
| `y_true`        | any  | 数据的实际值   |
| `y_pred`        | any  | 模型的预测值   |
| `sample_weight` | any  | 样本权重       |
| `multioutput`   | any  | 多输出方法选项 |

返回：array

## `mean_squared_error(y_true, y_pred, sample_weight, multioutput)`

暂时参数multioutput定义：为空数组，供后续开发使用。

| 参数            | 类型 | 说明           |
| --------------- | ---- | -------------- |
| `y_true`        | any  | 数据的实际值   |
| `y_pred`        | any  | 模型的预测值   |
| `sample_weight` | any  | 样本权重       |
| `multioutput`   | any  | 多输出方法选项 |

返回：array

## `mean_squared_log_error(y_true, y_pred, sample_weight, multioutput)`

暂时参数multioutput定义：为空数组，供后续开发使用。

| 参数            | 类型 | 说明           |
| --------------- | ---- | -------------- |
| `y_true`        | any  | 数据的实际值   |
| `y_pred`        | any  | 模型的预测值   |
| `sample_weight` | any  | 样本权重       |
| `multioutput`   | any  | 多输出方法选项 |

返回：array

## `median_absolute_error(y_true, y_pred, sample_weight, multioutput)`

暂时参数multioutput定义：为空数组，供后续开发使用。

| 参数            | 类型 | 说明           |
| --------------- | ---- | -------------- |
| `y_true`        | any  | 数据的实际值   |
| `y_pred`        | any  | 模型的预测值   |
| `sample_weight` | any  | 样本权重       |
| `multioutput`   | any  | 多输出方法选项 |

返回：array

## `r2_score(y_true, y_pred, sample_weight, multioutput)`

暂时参数multioutput定义：为空数组，供后续开发使用。 最佳可能的分数是1.0，它也可以是负的。

| 参数            | 类型 | 说明           |
| --------------- | ---- | -------------- |
| `y_true`        | any  | 数据的实际值   |
| `y_pred`        | any  | 模型的预测值   |
| `sample_weight` | any  | 样本权重       |
| `multioutput`   | any  | 多输出方法选项 |

返回：array

## `explained_variance_score(y_true, y_pred, sample_weight, multioutput)`

暂时参数multioutput定义：为空数组，供后续开发使用。 最好的得分是1.0, 值越小预测效果越差。

| 参数            | 类型 | 说明           |
| --------------- | ---- | -------------- |
| `y_true`        | any  | 数据的实际值   |
| `y_pred`        | any  | 模型的预测值   |
| `sample_weight` | any  | 样本权重       |
| `multioutput`   | any  | 多输出方法选项 |

返回：array

## `kurt(t, real)`

峰度。

| 参数   | 类型  | 说明                   |
| ------ | ----- | ---------------------- |
| `t`    | array | 一维数字数组，一维数据 |
| `real` |       | 实数，返回的峰度       |

返回：any

### 示例

```tsl
kurt(array(1, 2, 3, 4, 5), s);
return s;
// 返回：-1.2
```

## `Demo_sf_IntegerBessel_2()`

sf_IntegerBessel_2()教学函数。整数阶第二类贝塞尔函数，利用和的值可以递推出任意正整数阶第二类Bessel函数的值，这里阶数n=3,变量x=50。

返回：float

## `Demo_sf_IncompleteGamma()`

sf_IncompleteGamma()教学函数。不完全伽马函数，带入a=0.05,x=0.3求函数值。

返回：float

## `Demo_sf_RealBessel_1()`

sf_RealBessel_1()教学函数，实数阶第一类贝塞尔函数，带入阶数n=2,x=0.5求函数值。

返回：float

## `Demo_sf_F()`

sf_F()函数教学函数。F分布函数，带入随机变量f=9,自由度n1=2,自由度n2=3求积分值。

返回：float

## `Demo_sf_t()`

sf_T()函数教学函数。T分布函数，带入随机变量t=0.5,自由度n=4求积分值。

返回：float

## `Demo_sf_SinX()`

sf_SinX ()函数教学函数。正弦分布函数，带入随机变量x=14.5求积分值。

返回：float

## `Demo_sf_IncompleteBeta()`

sf_IncompleteBeta()函数教学函数。不完全贝塔函数，带入参a=1,b=2,自变量x=0.2求积分值。

返回：float

## `Demo_sf_Normal()`

sf_Normal()函数教学函数。正态分布函数，带入期望a=3,标准差d=15,随机变量x=-10求积分值。

返回：float

## `Demo_sf_EllipseX_2()`

sf_EllipseX_2()函数教学函数。第二类椭圆积分函数，带入变量k=1,椭圆参数=π6求积分值。

返回：float

## `Demo_sf_eX()`

sf_eX()函数教学函数。指数积分函数，带入变量x=1.65求积分值。

返回：float

## `Demo_sf_IntegerBessel_1()`

sf_IntegerBessel_1()函数教学函数。整数阶第一类贝塞尔函数，带入阶数n=3,变量x=50求函数值。

返回：float

## `Demo_sf_Beta()`

sf_Beta()函数教学函数。贝塔函数，带入变量x=1.5,y=2.5求积分值。

返回：float

## `Demo_sf_Error()`

sf_Error()函数教学函数。误差(概率)函数，带入变量x=0.05求积分值。

返回：float

## `Demo_sf_EllipseX_1()`

sf_EllipseX_1()函数教学函数。第一类椭圆积分函数，带入变量k=0.5,椭圆参数=π/2求积分值。

返回：float

## `Demo_sf_CosX()`

sf_CosX()函数教学函数。余弦积分函数，带入随机变量x=14.5求积分值。

返回：float

## `Demo_sf_RealBessel_2()`

sf_RealBessel_2 ()函数教学函数。实数阶第二类贝塞尔函数，带入阶数n=2,变量x=0.5求函数值。

返回：float

## `Demo_sf_Gamma()`

sf_Gamma()函数教学函数。伽马函数，带入x=1.5求积分值。

返回：float

## `Demo_sf_X2()`

sf_X2()函数教学函数。卡方分布函数，带入自由度n=3,随机变量x=5求积分值。

返回：float

## `randunid(n, row, col)`

产生离散均匀分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `n`   | integer                    | 分布参数,整数；        |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |

返回：any

### 示例

```tsl
return randunid(10, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randunid compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randhyge(m, k, n, row, col)`

产生超几何分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randhyge compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randpoiss(lambda, row, col)`

产生泊松分布的随机数

| 参数     | 类型                       | 说明                   |
| -------- | -------------------------- | ---------------------- |
| `lambda` | real                       | 分布参数,实数          |
| `row`    | integer or array of string | 行数或者行名字符串数组 |
| `col`    | integer or array of string | 列数或者列名字符串数组 |

返回：any

### 示例

```tsl
return randpoiss(10, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randpoiss compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `binofit(x, n, alpha)`

根据样本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的显著性水平下的区间估计
```

## `randunif(a, b, row, col)`

产生均匀分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randunif compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `expfit(x, alpha)`

根据样本x，x服从指数分布，估计该分布的参数parm

| 参数    | 类型          | 说明                   |
| ------- | ------------- | ---------------------- |
| `x`     | array of real | 指数分布样本，数字数组 |
| `alpha` | real          | 显著性水平，在0-1之间  |

返回：any

### 示例

```tsl
x := randexp(1, 100);
return expfit(x, 0.05);
// 输出：返回parm的估计已经他们的在alpha的显著性水平下的区间估计
```

## `randt(cv, row, col)`

产生学生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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randt compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randf(v1, v2, row, col)`

产生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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randf compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randexp(mu, row, col)`

产生指数分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `mu`  | real                       | 分布参数,实数,缺省为1  |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |

返回：any

### 示例

```tsl
return randexp(1, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randexp compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randch2(cv, row, col)`

产生卡方分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `cv`  | real                       | 卡方分布自由度,实数    |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |

返回：any

### 示例

```tsl
return randch2(30, 10, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randch2 compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randCauchy(a, b, row, col)`

产生柯西的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randCauchy compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randbeta(a, b, row, col)`

产生贝塔分布的随机数

| 参数  | 类型                       | 说明                     |
| ----- | -------------------------- | ------------------------ |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randbeta compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randrayl(b, row, col)`

产生瑞利分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `b`   | real                       | 分布参数,实数,缺省为1  |
| `row` | integer or array of string | 行数或者行名字符串数组 |
| `col` | integer or array of string | 列数或者列名字符串数组 |

返回：any

### 示例

```tsl
return randrayl(1, 100, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randrayl compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randwbl(a, b, row, col)`

产生威布尔分布的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randwbl compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `randLaplace(mu, b, row, col)`

产生拉普拉斯的随机数

| 参数  | 类型                       | 说明                   |
| ----- | -------------------------- | ---------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randLaplace compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `norminv(p, mu, sigma)`

正态逆函数

| 参数    | 类型           | 说明             |
| ------- | -------------- | ---------------- |
| `p`     | float \| array | 正态分布的概率   |
| `mu`    | float          | 分布的算术平均值 |
| `sigma` | float          | 方差             |

返回：float | array

### 示例

```tsl
return norminv(0.15, 0.5, 1); // -0.5364
```

## `corr_Kendall(x_values, y_values)`

计算 Kendall 秩相关系数。

| 参数       | 类型  | 说明       |
| ---------- | ----- | ---------- |
| `x_values` | array | 第一组数据 |
| `y_values` | array | 第二组数据 |

返回：float

## `Regress_GRStest(alpha_values, residual_matrix, factor_matrix)`

执行 GRS 检验。

| 参数              | 类型  | 说明                   |
| ----------------- | ----- | ---------------------- |
| `alpha_values`    | array | 截距项或 alpha 向量    |
| `residual_matrix` | array | 回归残差矩阵           |
| `factor_matrix`   | array | 因子收益或因子暴露矩阵 |

返回：array

## `Hypoth_PNUTest(samples, mean_diff, std_dev, tail, alpha)`

执行配对样本均值差 U 检验。

| 参数        | 类型   | 说明                                         |
| ----------- | ------ | -------------------------------------------- |
| `samples`   | array  | 两组配对样本数据                             |
| `mean_diff` | float  | 原假设均值差                                 |
| `std_dev`   | float  | 差值标准差；未知时传 `nil`                   |
| `tail`      | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`     | float  | 显著性水平                                   |

返回：array

## `variationCoefficient(x)`

变异系数。

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `x`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
return variationCoefficient(array(1, 2, 1, 2, 1, 2));
// 返回：0.33
```

## `selfStdDev(t, rmar)`

下方标准差。

| 参数   | 类型  | 说明                               |
| ------ | ----- | ---------------------------------- |
| `t`    | array | 数据表类型，一维数据               |
| `rmar` | real  | 实数，最低可接受的收益率(已折算过) |

返回：real

### 示例

```tsl
return selfStdDev(array(1, 2, 3, 4, 5), 3);
// 返回：0.89
```

## `skew(t, skew)`

偏斜度。

| 参数   | 类型  | 说明                   |
| ------ | ----- | ---------------------- |
| `t`    | array | 一维数字数组，一维数据 |
| `skew` | real  | 实数，返回的偏斜度     |

返回：any

### 示例

```tsl
skew(array(1, 2, 3, 4, 5, 7), s);
return s;
// 返回：0.46
```

## `meanAndPopnStdDevWithRate(data, rate, mean, stddev)`

带权重总体标准差以及平均值。

| 参数     | 类型  | 说明                 |
| -------- | ----- | -------------------- |
| `data`   | array | 一维数字数组         |
| `rate`   | array | 一维数字数组         |
| `mean`   | real  | 实数，均值，返回值   |
| `stddev` | real  | 实数，标准差，返回值 |

返回：real

### 示例

```tsl
meanAndPopnStdDevWithRate(array(1, 2, 3), array(1, 1, 1), m, s);
return m;
// 返回：2
```

## `betaAndAlpha(y, x, beta, alpha)`

得到斜率和截距。

| 参数    | 类型  | 说明               |
| ------- | ----- | ------------------ |
| `y`     | array | 一维数字数组       |
| `x`     | array | 一维数字数组       |
| `beta`  | real  | 实数，斜率，返回值 |
| `alpha` | real  | 实数，截距，返回值 |

返回：void

### 示例

```tsl
betaAndAlpha(array(3, 6), array(4, 12), k, b);
return k;
// 返回：0.375
```

## `regressionChannel(y, x, nowy, nowx, beta, alpha, top_alpha, bottom_alpha, top, bottom, pos, expectvalue)`

回归通道模型。

| 参数           | 类型  | 说明                    |
| -------------- | ----- | ----------------------- |
| `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
```

## `nanMean(a)`

计算含Nan一维数组的算术平均值

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
a := array(5, 6, 8, nan);
return nanMean(a);
// 结果：6.33
```

## `nanSum(a)`

计算含Nan一维数组的总和

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
a := array(5, 6, 8, nan);
return nanSum(a);
// 结果：19
```

## `nanStd(a)`

计算含Nan一维数组的标准差的估计（样本标准差）

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
a := array(5, 6, 8, nan);
return nanStd(a);
// 结果：1.53
```

## `nanVariance(a)`

计算含Nan一维数组的方差的估计（样本方差）

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
a := array(5, 6, 8, nan);
return nanVariance(a);
// 结果：2.33
```

## `nanPopnStd(a)`

计算含Nan一维数组的总体标准差

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
a := array(5, 6, 8, nan);
return nanPopnStd(a);
// 结果：1.25
```

## `expdMax(r)`

统计数组累计到当前行的最大值序列

| 参数 | 类型          | 说明                                                         |
| ---- | ------------- | ------------------------------------------------------------ |
| `r`  | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |

返回：array

### 示例

```tsl
r := array(-1, 2, -3, 9);
return expdMax(r); // array(-1,2,2,9)
```

## `expdMin(r)`

统计数组累积到当前行的最小值序列

| 参数 | 类型          | 说明                                                         |
| ---- | ------------- | ------------------------------------------------------------ |
| `r`  | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |

返回：array

### 示例

```tsl
r := array(-1, 2, -3, 9);
return expdMin (r); // array(-1,-1,-3,-3)
```

## `expdSum(r)`

返回数组累积到当前行的求和序列

| 参数 | 类型          | 说明                                                         |
| ---- | ------------- | ------------------------------------------------------------ |
| `r`  | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |

返回：array

### 示例

```tsl
r := array(-1, 2, -3, 9);
return expdSum (r); // array(-1,1,-2,7)
```

## `expdProduct(r)`

返回数组累积到当前行的累乘序列

| 参数 | 类型          | 说明                                                         |
| ---- | ------------- | ------------------------------------------------------------ |
| `r`  | array of real | 数组，一维或二维（此时按列统计）数字数组，也可以为二维数据表 |

返回：array

### 示例

```tsl
r := array(-1, 2, -3, 9);
return expdProduct (r); // array(-1,-2,6,54)
```

## `expdVar(r, ddof)`

返回数组累积到当前行的方差序列

| 参数   | 类型          | 说明                                                         |
| ------ | ------------- | ------------------------------------------------------------ |
| `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)
```

## `expdStd(r, ddof)`

返回数组累积到当前行的标准差序列

| 参数   | 类型          | 说明                                                         |
| ------ | ------------- | ------------------------------------------------------------ |
| `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)
```

## `nanPopnVariance(a)`

计算含Nan一维数组的总体方差

| 参数 | 类型  | 说明         |
| ---- | ----- | ------------ |
| `a`  | array | 一维数字数组 |

返回：real

### 示例

```tsl
a := array(5, 6, 8, nan);
return popnVariance(a);
// 结果：1.56
```

## `nanRankArr(a, f_name, sortorder)`

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)
```

## `nanPercentRankArr(a, f_name)`

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)
```

## `hist(a, b, center)`

统计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);
// 输出：，一维数字数组
```

## `sf_normpdf(x, mu, sigma, v)`

正态分布的概率密度函数，输入随机变量，返回随机变量对应的概率密度

| 参数    | 类型  | 说明                                          |
| ------- | ----- | --------------------------------------------- |
| `x`     | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu`    | float | 正态分布参数，均值，实数类型                  |
| `sigma` | float | 正态分布参数，标准差，实数类型                |
| `v`     | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_normcdf(x, mu, sigma, v)`

计算随机变量在正态分布, 均值为mu，方差为sigma条件下的分布函数,返回分布函数值。

| 参数    | 类型  | 说明                                            |
| ------- | ----- | ----------------------------------------------- |
| `x`     | array | :随机变量，可以是实数，也可以是一个实数二维数组 |
| `mu`    | float | 正态分布的均值，实数类型                        |
| `sigma` | float | 正态分布的标准差，大于0的实数                   |
| `v`     | array | 变参返回x对应的正态分布函数的值，实数或二维数组 |

返回：any

## `sf_norminv(y, mu, sigma, x)`

正态分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

| 参数    | 类型  | 说明                                                        |
| ------- | ----- | ----------------------------------------------------------- |
| `y`     | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu`    | float | 正态分布参数，均值，实数类型                                |
| `sigma` | float | 正态分布参数，标准差，实数类型                              |
| `x`     | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `randnorm(mu, sigma, row, col)`

产生正态分布的随机数

| 参数    | 类型                       | 说明                           |
| ------- | -------------------------- | ------------------------------ |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randnorm compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `normfit(x, alpha)`

根据样本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的显著性水平下的区间估计
```

## `sf_unidpdf(x, n, v)`

离散均匀分布的概率函数，输入随机变量，返回随机变量对应的概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n`  | any   | 分布参数,整数；                               |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_unidcdf(x, n, v)`

离散均匀分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n`  | any   | 分布参数,整数；                               |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_unidinv(y, n, x)`

离散均匀分布的分布逆函数，输入累计概率值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `n`  | any   | 分布参数,整数                                               |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_geopdf(x, p, v)`

几何分布的概率函数，输入随机变量，返回随机变量对应的概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数            |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_geocdf(x, p, v)`

几何分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `p`  | float | p:一次试验成功的概率,为0,1之间的实数          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_geoinv(y, p, x)`

几何分布的分布逆函数，输入累计概率值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数                          |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `randgeo(n, p, row, col)`

产生几何分布的随机数

| 参数  | 类型                       | 说明                                   |
| ----- | -------------------------- | -------------------------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randgeo compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `sf_hygepdf(x, m, k, n, v)`

超几何分布的概率函数，输入随机变量，返回随机变量对应的概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `m`  | any   | 总体数目,非负整数                             |
| `k`  | any   | 总体标数目,非负整数                           |
| `n`  | any   | 抽样数目,非负整数                             |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_hygecdf(x, m, k, n, v)`

超几何分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `m`  | any   | 总体数目,非负整数                             |
| `k`  | any   | 总体标数目,非负整数                           |
| `n`  | any   | 抽样数目,非负整数                             |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_hygeinv(y, m, k, n, x)`

超几何分布的分布逆函数，输入累计概率值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `m`  | any   | 总体数目,非负整数                                           |
| `k`  | any   | 总体标数目,非负整数                                         |
| `n`  | any   | 抽样数目,非负整数                                           |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_binopdf(x, n, p, v)`

二项分布的概率函数，输入随机变量，返回随机变量对应的概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n`  | any   | 试验总量,为大于0的整数；                      |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数            |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_binocdf(x, n, p, v)`

二项分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `n`  | any   | 试验总量,为大于0的整数；                      |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数            |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_binoinv(y, n, p, x)`

二项分布的分布逆函数，输入累计概率值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `n`  | any   | 试验总量,为大于0的整数；                                    |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数                          |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `randbino(n, p, row, col)`

产生二项分布的随机数

| 参数  | 类型                       | 说明                               |
| ----- | -------------------------- | ---------------------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randbino compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `sf_nbinpdf(x, r, p, v)`

负二项分布的概率函数，输入随机变量，返回随机变量对应的概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `r`  | any   | 试验成功的次数,为大于0的整数                  |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数            |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_nbincdf(x, r, p, v)`

负二项分布的累计概率函数，输入随机变量，返回随机变量对应的累计概率

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `r`  | any   | 试验成功的次数,为大于0的整数                  |
| `p`  | float | 一次试验成功的概率,为0,1之间的实数            |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `randnbin(r, p, row, col)`

产生负二项分布的随机数

| 参数  | 类型                       | 说明                               |
| ----- | -------------------------- | ---------------------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randnbin compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `sf_unifpdf(x, a, b, v)`

均匀分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 均匀分布的下限,实数                           |
| `b`  | float | 均匀分布的上限,实数                           |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_unifcdf(x, a, b, v)`

均匀分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 均匀分布的下限,实数                           |
| `b`  | float | 均匀分布的上限,实数                           |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_unifinv(y, a, b, x)`

均匀分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 均匀分布的下限,实数                                         |
| `b`  | float | 均匀分布的上限,实数                                         |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `uniffit(x, alpha)`

根据样本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的显著性水平下的区间估计
```

## `sf_poisspdf(x, lambda, v)`

泊松分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数     | 类型  | 说明                                          |
| -------- | ----- | --------------------------------------------- |
| `x`      | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `lambda` | float | 分布参数,实数                                 |
| `v`      | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_poisscdf(x, lambda, v)`

泊松分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数     | 类型  | 说明                                          |
| -------- | ----- | --------------------------------------------- |
| `x`      | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `lambda` | float | 分布参数,实数                                 |
| `v`      | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_poissinv(y, lambda, x)`

泊松分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数     | 类型  | 说明                                                        |
| -------- | ----- | ----------------------------------------------------------- |
| `y`      | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `lambda` | float | 分布参数,实数                                               |
| `x`      | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `poissfit(x, alpha)`

根据样本x，x服从泊松分布，估计该分布的参数lambda

| 参数    | 类型          | 说明                   |
| ------- | ------------- | ---------------------- |
| `x`     | array of real | 泊松分布样本，数字数组 |
| `alpha` | real          | 显著性水平，在0-1之间  |

返回：any

### 示例

```tsl
x := randpoiss(1, 100);
return poissfit(x, 0.05);
// 输出：返回lambda的估计以及他们的在alpha的显著性水平下的区间估计
```

## `sf_expinv(y, mu, x)`

指数分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 分布参数,实数,缺省为1                                       |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_ch2pdf(x, cv, v)`

卡方分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 卡方分布自由度,实数                           |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_ch2cdf(x, cv, v)`

卡方分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 卡方分布自由度,实数                           |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_ch2inv(y, cv, x, return_value)`

卡方分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数           | 类型  | 说明                                                        |
| -------------- | ----- | ----------------------------------------------------------- |
| `y`            | any   | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `cv`           | float | 卡方分布自由度,实数                                         |
| `x`            | any   | 可选，输出参数，随机变量值，类型和y一样                     |
| `return_value` | any   | 返回随机变量值，类型和y一样                                 |

返回：array

## `sf_tpdf(x, cv, v)`

学生T分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 学生T分布自由度,实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_tcdf(x, cv, v)`

学生T分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 学生T分布自由度,实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_tinv1(y, cv, x)`

学生T分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `cv` | float | 学生T分布自由度,实数                                        |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_fpdf(x, v1, v2, v)`

F分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `v1` | float | 分子自由度,大于0的实数                        |
| `v2` | float | 分母自由度,大于0的实数                        |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_fcdf(x, v1, v2, v)`

F分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `v1` | float | 分子自由度,大于0的实数                        |
| `v2` | float | 分母自由度,大于0的实数                        |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_finv1(y, v1, v2, x)`

F分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                       |
| ---- | ----- | ---------------------------------------------------------- |
| `y`  | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `v1` | float | 分子自由度,大于0的实数                                     |
| `v2` | float | 分母自由度,大于0的实数                                     |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                |

返回：array

## `sf_gampdf(x, a, b, v)`

伽马分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 形状参数,大于0的实数                          |
| `b`  | float | 尺度参数,大于0的实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_gamcdf(x, a, b, v)`

伽马分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 形状参数,大于0的实数                          |
| `b`  | float | 尺度参数,大于0的实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_gaminv(y, a, b, x)`

伽马分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 形状参数,大于0的实数                                        |
| `b`  | float | 尺度参数,大于0的实数                                        |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_betacdf(x, a, b, v)`

贝塔分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | beta分布参数1,实数,大于0                      |
| `b`  | float | beta分布参数2,实数,大于0                      |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_raylpdf(x, b, v)`

瑞利分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `b`  | float | 分布参数,实数,缺省为1                         |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_raylcdf(x, b, v)`

瑞利分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `b`  | float | 分布参数,实数,缺省为1                         |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_raylinv(y, b, x)`

瑞利分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `b`  | float | 分布参数,实数,缺省为1                                       |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_wblpdf(x, a, b, v)`

威布尔分布的密度函数，输入随机变量，返回随机变量对应的密度函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 比例参数,实数,大于0                           |
| `b`  | float | 形状参数,实数,大于0                           |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_wblcdf(x, a, b, v)`

威布尔分布的分布函数，输入随机变量，返回随机变量对应的分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 比例参数,实数,大于0                           |
| `b`  | float | 形状参数,实数,大于0                           |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_wblinv(y, a, b, x)`

威布尔分布的分布逆函数，输入分布函数值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 比例参数,实数,大于0                                         |
| `b`  | float | 形状参数,实数,大于0                                         |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_lognpdf(x, mu, sigma, v)`

对数正态分布的概率密度函数，输入随机变量，返回随机变量对应的概率密度

| 参数    | 类型  | 说明                                          |
| ------- | ----- | --------------------------------------------- |
| `x`     | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu`    | float | 对数正态分布参数，均值，实数类型              |
| `sigma` | float | 对数正态分布参数，标准差，实数类型            |
| `v`     | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_logncdf(x, mu, sigma, v)`

对数正态分布的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值

| 参数    | 类型  | 说明                                          |
| ------- | ----- | --------------------------------------------- |
| `x`     | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu`    | float | 对数正态分布参数，均值，实数类型              |
| `sigma` | float | 对数正态分布参数，标准差，实数类型            |
| `v`     | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_logninv(y, mu, sigma, x)`

对数正态分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

| 参数    | 类型  | 说明                                                        |
| ------- | ----- | ----------------------------------------------------------- |
| `y`     | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu`    | float | 对数正态分布参数，均值，实数类型                            |
| `sigma` | float | 对数正态分布参数，标准差，实数类型                          |
| `x`     | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `randlogn(mu, sigma, row, col)`

产生对数正态分布的随机数

| 参数    | 类型                       | 说明                               |
| ------- | -------------------------- | ---------------------------------- |
| `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"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randlogn compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

## `sf_Laplacepdf(x, mu, b, v)`

拉普拉斯的概率密度函数，输入随机变量，返回随机变量对应的概率密度

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 位置参数,实数                                 |
| `b`  | float | 尺度参数,大于0的实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_Laplacecdf(x, mu, b, v)`

拉普拉斯的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 位置参数,实数                                 |
| `b`  | float | 尺度参数,大于0的实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_Laplaceinv(y, mu, b, x)`

拉普拉斯的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 位置参数,实数                                               |
| `b`  | float | 尺度参数,大于0的实数                                        |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_Cauchypdf(x, a, b, v)`

柯西的概率密度函数，输入随机变量，返回随机变量对应的概率密度

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 位置参数,实数                                 |
| `b`  | float | 尺度参数,大于0的实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_Cauchycdf(x, a, b, v)`

柯西的累计概率或者分布函数，输入随机变量，返回随机变量对应的累计概率，或者分布函数值

| 参数 | 类型  | 说明                                          |
| ---- | ----- | --------------------------------------------- |
| `x`  | array | :随机变量，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 位置参数,实数                                 |
| `b`  | float | 尺度参数,大于0的实数                          |
| `v`  | array | 变参返回，该函数也支持直接返回，类型和x一样   |

返回：any

## `sf_Cauchyinv(y, a, b, x)`

柯西的分布逆函数，输入分布函数或者累计概率值，返回随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a`  | float | 位置参数,实数                                               |
| `b`  | float | 尺度参数,大于0的实数                                        |
| `x`  | array | 变参返回，该函数也支持直接返回，类型和y一样                 |

返回：any

## `sf_betainv1(y, a, b)`

贝塔分布的分布逆函数，输入分布函数值，返回随机变量值。功能与sf_betainv一致，输出接口不一样。

| 参数 | 类型  | 说明                                                       |
| ---- | ----- | ---------------------------------------------------------- |
| `y`  | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a`  | float | beta分布参数1,实数,大于0                                   |
| `b`  | float | beta分布参数2,实数,大于0                                   |

返回：array

## `sf_exp(x, mu, v)`

指数分布累计概率

| 参数 | 类型  | 说明                                         |
| ---- | ----- | -------------------------------------------- |
| `x`  | array | 随机变量，可以使用实数，也可以是一个实数数组 |
| `mu` | float | 分布参数                                     |
| `v`  | array | 返回值                                       |

返回：array

## `Estimate_SNU(x, d, alpha, tail)`

在1-alpha置信水平下，分为标准差未知和已知两种情况求单个正态总体均值的置信区间（或下置信区间，上置信区间）。

| 参数    | 类型   | 说明                                                    |
| ------- | ------ | ------------------------------------------------------- |
| `x`     | array  | 样本序列，一维数组                                      |
| `d`     | float  | 正态总体的标准差，若未知，则输入nil，实数               |
| `alpha` | float  | 显著性水平，实数，在0,1之间                             |
| `tail`  | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |

返回：array

## `Estimate_TNU(x, d, alpha, tail, equal)`

在1-alpha置信水平下，分为标准差未知和已知两种情况求两个正态总体均值差的置信区间（或下置信区间，上置信区间）;

| 参数    | 类型   | 说明                                                               |
| ------- | ------ | ------------------------------------------------------------------ |
| `x`     | array  | 样本序列,含两行的二维数字数组，每行为一个样本                      |
| `d`     | array  | 正态总体的标准差数组，若未知，则输入array(nil,nil)，为一维数组类型 |
| `alpha` | float  | 显著性水平,实数，在0,1之间                                         |
| `tail`  | string | 求取置信区间类型，字符串，取both,left,right，缺省取both            |
| `equal` | bool   | 当标准差未知时，方差是否相等，布尔型                               |

返回：array

## `Estimate_SND(x, alpha, tail)`

在1-alpha置信水平下，求单个正态总体方差的置信区间（或下置信区间，上置信区间）

| 参数    | 类型   | 说明                                                    |
| ------- | ------ | ------------------------------------------------------- |
| `x`     | array  | 样本序列，一维数组                                      |
| `alpha` | float  | 显著性水平，实数，在0,1之间                             |
| `tail`  | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |

返回：array

## `Estimate_TND(x, alpha, tail)`

在1-alpha置信水平下，求两个正态总体方差之比的置信区间（或下置信区间，上置信区间）

| 参数    | 类型   | 说明                                                    |
| ------- | ------ | ------------------------------------------------------- |
| `x`     | array  | 样本序列,含两行的二维数字数组，每行为一个样本           |
| `alpha` | float  | 显著性水平,实数，在0,1之间                              |
| `tail`  | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |

返回：array

## `Estimate_SP(mx, alpha, tail)`

在1-alpha置信水平下，求比率或说概率的置信区间（或下置信区间，上置信区间）；

| 参数    | 类型   | 说明                                                    |
| ------- | ------ | ------------------------------------------------------- |
| `mx`    | float  | 频率，实数；n;样本容量，整数                            |
| `alpha` | float  | 显著性水平,实数，在0,1之间                              |
| `tail`  | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |

返回：array

## `Estimate_TP(p, alpha, tail)`

在1-alpha置信水平下，求两个总体的比率或说概率差的置信区间（或下置信区间，上置信区间）

| 参数    | 类型   | 说明                                                    |
| ------- | ------ | ------------------------------------------------------- |
| `p`     | array  | 频率数组；n;样本容量数组，一维数组                      |
| `alpha` | float  | 显著性水平,实数，在0,1之间                              |
| `tail`  | string | 求取置信区间类型，字符串，取both,left,right，缺省取both |

返回：array

## `Hypoth_TailRes(sta, v, tail, alpha)`

根据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

## `normPlot(x, return_type)`

基于正态概率的正态性检验, 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
```

## `Hypoth_Kstest(data, tail, alpha, cdf)`

在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)`

在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_IndepTest(x, alpha)`

列联表检验法检验两个随机变量的独立性检验，返回的结果是一个数组，第一个数为统计值，二为p值，三为原假设的值（0表示拒绝，1表示接受） 模型表达： 原假设：H0:X 与Y 相互独立 检验统计量： 其中 ，，

| 参数    | 类型  | 说明                             |
| ------- | ----- | -------------------------------- |
| `x`     | array | 样本矩阵，为二维数组类型         |
| `alpha` | float | 显著性水平，实数或整数，在01之间 |

返回：array

## `Hypoth_KruskalWallis(x, alpha)`

两个或多个随机变量的独立性检验。本模型原假设为各随机变量相互独立。

| 参数    | 类型  | 说明                                     |
| ------- | ----- | ---------------------------------------- |
| `x`     | array | 样本矩阵，为二维数组类型，每行为一个样本 |
| `alpha` | float | 显著性水平，实数或整数，在01之间         |

返回：array

## `Hypoth_WilcoxonTest(x, m0, tail, alpha)`

非参数检验-Wilcoxon符号秩检验。单样本Wilcoxon符号秩检验 原理：把观测值和零假设的中心位置之差的绝对值的秩按照不同的符号相加作为其检验统计量。 此检验假定样本来自于连续对称总体。 计算步骤： 1、计算样本点到检验值的距离； 2、对上述距离的绝对值进行排序并计算秩，对相同的样本点则取平均秩； 3、分别计算大于检验值与小于检验值样本的秩和； 4、对得到的统计量计算p值

| 参数    | 类型   | 说明                                                                                    |
| ------- | ------ | --------------------------------------------------------------------------------------- |
| `x`     | array  | 样本序列，为一维数字数组类型                                                            |
| `m0`    | float  | 检验值，为实数类型                                                                      |
| `tail`  | string | 假设检验的三种类型，both（双侧检验），left（左侧检验），right（右侧检验），为字符串类型 |
| `alpha` | float  | 显著性水平，在0-1之间，为实数类型                                                       |

返回：array

## `Hypoth_McNemarTest(x, alpha)`

非参数检验-McNemar检验。 对配对样本进行McNemar检验 McNemar检验以研究对象自身为对照，检验其两组样本变化是否显著 要求待检验的两组样本的观察值是二分类数据 检验统计量服从卡方分布

| 参数    | 类型  | 说明                               |
| ------- | ----- | ---------------------------------- |
| `x`     | array | 样本统计列联表，为二维数字数组类型 |
| `alpha` | float | 显著性水平，在0-1之间，为实数类型  |

返回：array

## `Hypoth_PWilcoxonTest(x, m0, tail, alpha)`

非参数检验-配对样本Wilcoxon符号秩检验,配对样本的Wilcoxon符号秩检验 要求样本矩阵中两个样本是配对出现的 可以按照实际需求选择双侧或单侧检验

| 参数    | 类型   | 说明                                    |
| ------- | ------ | --------------------------------------- |
| `x`     | array  | 一维数字数组,样本矩阵                   |
| `m0`    | float  | 实数,检验值                             |
| `tail`  | string | 字符串,双侧检验 or 左侧检验 or 右侧检验 |
| `alpha` | float  | 实数,显著性水平                         |

返回：array

## `corr(a, _type, tail)`

计算相关系数矩阵及其检验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值
```

## `corrcoef(a)`

计算简单相关系数矩阵及其检验P值，以及简单相关系数置信区间的上下界（显著性水平为0.05）

| 参数 | 类型             | 说明                                                                                                                                                                                                                         |
| ---- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `a`  | array,tablearray | 样本数据观测矩阵，二维数字数组返回结果:Ret["r"]:样本数据观测矩阵的简单相关系数矩阵Ret["p"]:检验相关系数是否显著的P值，二维数组Ret["rlo"]:简单相关系数置信区间的下界，二维数组Ret["rup"]:简单相关系数置信区间的上界，二维数组 |

返回：any

### 示例

```tsl
a := rand(7, 4);
return corrcoef(a); // 返回简单相关系数分析
// 输出：结果：
```

## `distance(x, y, name)`

计算样本和样本间的距离或样本数据观测矩阵的距离矩阵，其中距离包括欧氏距离，欧氏距离平方，方差加权距离，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));
```

## `discrim(a, x, method, options)`

按照给定分类训练样本，根据训练结果对待定样本类别判定，也可作为原样本的回代检验

| 参数      | 类型          | 说明                                              |
| --------- | ------------- | ------------------------------------------------- |
| `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);
// 计算结果：
```

## `princomp(x, ep, is_stand, resid)`

主成分分析，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);
// 输出：
// Execute script error at Line:14
// function:__main__:line 14:instruction:usercall: function:princomp compile error or not found
// function:__main__:line 14:instruction:usercall: function execute error
```

## `corr_canonical(x, y, alpha, standarize_choice)`

典型相关分析，默认条件从中心化数据出发衡量两组随机变量之间的相关性

| 参数                | 类型  | 说明                                                           |
| ------------------- | ----- | -------------------------------------------------------------- |
| `x`                 | array | X属性样本数据，二维数字数组，详见实例分析                      |
| `y`                 | array | Y属性样本数据，二维数字数组，详见实例分析                      |
| `alpha`             | float | 置信度，实数型，0~1之间，缺省值0(不执行典型相关系数显著性检验) |
| `standarize_choice` | any   | 原始数据标准化选择，整数型，0~7，缺省值为0(保持原始数据)       |

返回：array

## `corr_Spearman(x, y)`

Spearman相关系数，简称斯皮尔曼相关系数，经常用希腊字母ρ表示。 它是衡量两个变量的依赖性的非参数指标。它利用单调方程评价两个统计变量的相关性。 如果数据中没有重复值，并且当两个变量完全单调相关时，斯皮尔曼相关系数则为+1或1。

| 参数 | 类型  | 说明                |
| ---- | ----- | ------------------- |
| `x`  | array | 一维数组，随机变量x |
| `y`  | array | 一维数组，随机变量y |

返回：float

## `cov2CorrMatrix(a)`

协方差矩阵转为相关系数矩阵

| 参数 | 类型  | 说明                     |
| ---- | ----- | ------------------------ |
| `a`  | array | 二维数字数组，协方差矩阵 |

返回：array

### 示例

```tsl
a := covariance(rand(4, 3));
return cov2CorrMatrix(a);
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:rand: function:covariance compile error or not found
// function:__main__:line 1:instruction:rand: function execute error
```

## `corrMatrixAdjust(a, adjust_type, n)`

相关系数矩阵调整：将相关系数大或小的样本排在一起（重构）,输出结构调整，不改变相关系数本身

| 参数          | 类型       | 说明                            |
| ------------- | ---------- | ------------------------------- |
| `a`           | array      | 二维数字数组，协方差矩阵        |
| `adjust_type` | userdefine | 用户自定义，调整方式，默认为0   |
| `n`           | integer    | 整数，分为N类，AdjustType=1专用 |

返回：array

### 示例

```tsl
a := corr(rand(6, 6));
return corrMatrixAdjust(a, 1, 5);
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:rand: function:corr compile error or not found
// function:__main__:line 1:instruction:rand: function execute error
```

## `Regress_domin_marginal(y, x, variable, option)`

相对重要性分析-边际R2法 功能描述： 获取指定变量或所有变量的相对重要性分析， 与公式法相比，考虑了变量的相互关系，且贡献为正， 但是贡献度的和近似等于R2

| 参数       | 类型  | 说明                                                                                                                                                     |
| ---------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y`        | array | 因变量，被解释变量，是一维数字数组                                                                                                                       |
| `x`        | array | 自变量，解释变量，是二维数字数组                                                                                                                         |
| `variable` | any   | 指定变量，通过给X的列名，来指定单个变量，给nil时，表示所有变量【默认】                                                                                   |
| `option`   | any   | 相对重要性的算法选择；1:利用包含指定变量回归中贡献度的均值计算【默认】，即平均R2边际效用法；0:利用完整回归中剔除其他变量的贡献度计算，即快速R2边际效用法 |

返回：array

## `Regression_WLS(y, x, alpha, constant, wtype, m1, m2, steps, wweight)`

加权最小二乘法回归, 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

## `regression(y, x, alpha, constant, options)`

线性回归方程的最小二乘法参数估计及检验（可选择是否包含常数项），返回结果有回归系数、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);
// 输出：
// Execute script error at Line:14
// function:__main__:line 14:instruction:usercall: function:regression compile error or not found
// function:__main__:line 14:instruction:usercall: function execute error
```

## `Regress_Stepwise(y, x, a_e, a_d)`

逐步回归，默认的回归方程包含常数项，程序返回的结果:ret\["x"\]为筛选的变量的下标，ret\["regress"\]为筛选变量与因变量进行回归的结果。

| 参数  | 类型  | 说明                                             |
| ----- | ----- | ------------------------------------------------ |
| `y`   | array | 因变量序列，为一维数组类型                       |
| `x`   | array | 自变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `a_e` | float | 选取变量的显著性水平，默认为0.05，为实数类型     |
| `a_d` | float | 剔除变量的显著性水平，默认为0.1，为实数类型      |

返回：array

## `Regress_pri(y, x, exps, alpha)`

主成分回归，利用解释变量(Z 分数标准化)进行主成分分析降维得到的主成分，来对被解释变量(Z分数标准化)进行回归，进而消除多重共线性

| 参数    | 类型  | 说明                                                                                                                                               |
| ------- | ----- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `y`     | array | 被解释变量序列，为一维数组类型                                                                                                                     |
| `x`     | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量                                                                                                 |
| `exps`  | float | 主成分累计贡献率，作为选取主成分数目的依据，当为小数时，代表累计贡献率的阀值，比如0.85，当为整数时，代表取的主成分的个数，比如2表示取前2个主成分。 |
| `alpha` | float | 显著性水平，实数或整数，在01之间                                                                                                                   |

返回：array

## `Regress_NLM(func, x, y, initial)`

多元非线性回归，采用Marquardt方法求多元非线性方程的最小二乘回归系数。

| 参数      | 类型   | 说明                                               |
| --------- | ------ | -------------------------------------------------- |
| `func`    | string | 回归方程函数名，为字符串类型                       |
| `x`       | array  | 解释变量矩阵，为二维数组类型，每一列为一个解释变量 |
| `y`       | array  | 被解释变量序列，为一维数组类型                     |
| `initial` | array  | 估计参数初始值，一维数字数组                       |

返回：array

## `Regress_Binary(y, x, extimation, methods, constant, alpha)`

二元离散选择模型。返回结果有方程的系数、负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_Logistic(y, x, constant, alpha)`

logit二元离散选择模型。返回结果有方程的系数、负2倍对数似然值和Wald检验（原假设为解释变量对被解释变量影响不显著，检验包含统计量、P值和原假设的值1表示接受原假设，0表示拒绝原假设）

| 参数       | 类型  | 说明                                                                                                                       |
| ---------- | ----- | -------------------------------------------------------------------------------------------------------------------------- |
| `y`        | array | 因变量序列，为一维数组类型；                                                                                               |
| `x`        | array | 自变量矩阵，为二维数组类型，每一列为一个自变量；自变量x的长度应小于等于因变量y，否则会报错，最好等于，若小于会对结果有影响 |
| `constant` | bool  | object                                                                                                                     |
| `alpha`    | float | 显著性水平，一般为5%，也有1%和10%，数值越小，判断越严格；默认为0.05                                                        |

返回：array

## `Regress_Constraint(y, x, constant, a, b, aeq, beq, alpha, options, lb, ub)`

线性约束最小二乘回归

| 参数       | 类型  | 说明                                                       |
| ---------- | ----- | ---------------------------------------------------------- |
| `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_RSquare(y, u, weight, dtype)`

计算回归方程的拟合程度R平方，可适用与一元或多元的线性回归；

| 参数     | 类型  | 说明                                 |
| -------- | ----- | ------------------------------------ |
| `y`      | array | 因变量序列，为一维数组类型；         |
| `u`      | array | 回归方程的残差序列，为一维数组类型； |
| `weight` | array | 一维数字数组,权重                    |
| `dtype`  | any   | 整型,返回数据类型                    |

返回：array

## `Regress_AdjustedR2(r, t, k)`

计算回归方程经调整的R平方，考虑由于加入新的解释变量而产生自由度的损失；

| 参数 | 类型 | 说明                                |
| ---- | ---- | ----------------------------------- |
| `r`  | any  | 回归方程的拟合优度R平方，实数类型； |
| `t`  | any  | 样本的容量，整数类型；              |
| `k`  | any  | 自变量的个数；                      |

返回：any

## `Regress_FTest(y, u, k, alpha)`

在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_TTest(x, a, u, k, alpha, constant)`

在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_JBTest(y, alpha)`

在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_AicAndSbic(u, k, t)`

信息准则函数，判断序列的最佳滞后阶数，分别计算AIC和SBIC统计量，并把结果赋值到一个一维数组，第一个是Aic值，第二个Sbic值。当选择最佳滞后阶数时，统计量越小越好。 AIC和SBIC的表达式如下所示： 其中：T为样本容量；k为自变量个数；u为残差；

| 参数 | 类型  | 说明                                 |
| ---- | ----- | ------------------------------------ |
| `u`  | array | 回归方程的残差序列，为一维数组类型； |
| `k`  | any   | 解释变量的个数；                     |
| `t`  | any   | 样本的容量，整数类型；               |

返回：array

## `Regress_White(y, x, crr, alpha)`

包含无交叉项和交叉项两种，用于检验回归方程的异方差性，原假设为不存在异方差（Hypothesis的值0表示拒绝，1表示接受）

| 参数    | 类型  | 说明                                                             |
| ------- | ----- | ---------------------------------------------------------------- |
| `y`     | array | 被解释变量，为一维数组类型                                       |
| `x`     | array | 解释变量，为二维数组类型                                         |
| `crr`   | any   | 交叉项，0为无交叉项，1为有交叉项                                 |
| `alpha` | float | 1-alpha为置信水平，一般为5%，也有1%和10%，数值越小，判断越严格； |

返回：array

## `Regress_QRlsq(y, x, u, constant)`

线性回归方程基于QR分解的最小二乘法参数估计（可选择是否包含常数项），返回回归方程的系数，如果有常数项则排在第一项

| 参数       | 类型  | 说明                                             |
| ---------- | ----- | ------------------------------------------------ |
| `y`        | array | 因变量序列，为一维数组类型；                     |
| `x`        | array | 自变量矩阵，为二维数组类型，每一列为一个自变量； |
| `u`        | array | 残差序列，为一维数组类型；                       |
| `constant` | bool  | object                                           |

返回：array

## `Regress_VIF(x)`

x的多重共线性分析，输出方差扩大因子VIF指标和条件数，一般VIF大于10，表明存在严重的多重共线性；5<VIF<10,表明存在多重共线性；如果VIF小于5的话，表明这种回归模型的多重共线性可以接受。用条件数判断多重共线性的准则 0<k<10时,设计矩阵X没有多重共线性; 10≤k<100时,认为X存在较强的多重共线性; 当k≥100时,则认为存在严重的多重共线性。

| 参数 | 类型  | 说明                   |
| ---- | ----- | ---------------------- |
| `x`  | array | 数据，每一列是一个指标 |

返回：array

## `boxcox(y)`

在做线性回归的过程中，不可观测的误差可能是和预测变量相关，于是给线性回归的最小二乘法估计系数的结果带来误差，为了解决这样的方差齐性问题，所以考虑对相应应变量做Box-Cox变换，变换之后，可以一定程度上减小不可观测的误差和预测变量的相关性

| 参数 | 类型          | 说明                       |
| ---- | ------------- | -------------------------- |
| `y`  | array of real | 因变量序列，为一维数组类型 |

返回：array

### 示例

```tsl
data := rand(100);
return boxcox(data);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:boxcox compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `Regress_HettestSpearman(y, x, alpha, constant)`

基于等级相关系数的异方差检验

| 参数       | 类型  | 说明                            |
| ---------- | ----- | ------------------------------- |
| `y`        | array | 数组，因变量，一维数字数组      |
| `x`        | array | 数组，自变量，二维数字数组      |
| `alpha`    | float | 实数，显著性水平，值域为\[0,1\] |
| `constant` | bool  | object                          |

返回：array

## `Regress_TTest_White(x, a, u, alpha, constant, v_ols)`

用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_TTest_NW(x, a, u, alpha, constant, al, v_ols)`

用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

## `Regression_OLS_White(y, x, constant, alpha)`

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

## `singleRegression(x, y, call_back)`

单元回归

| 参数        | 类型   | 说明                         |
| ----------- | ------ | ---------------------------- |
| `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);
// 输出：
// Execute script error at Line:4
// function:__main__:line 4:instruction:usercall: function:singleRegression compile error or not found
// function:__main__:line 4:instruction:usercall: function execute error
```

## `polynomialRegression(x, y, m)`

多项式回归

| 参数 | 类型    | 说明                        |
| ---- | ------- | --------------------------- |
| `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);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:polynomialRegression compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```

## `MTM_f(n, m, _type)`

动力指标

| 参数    | 类型 | 说明     |
| ------- | ---- | -------- |
| `n`     | any  | 天数     |
| `m`     | any  | 天数     |
| `_type` | any  | 结果类型 |

返回：any

## `ar_GetValue2()`

数组类型教学函数。返回当前股票历史资产负债表序列的第四项，与系统参数(股票)相关。

返回：array

## `ar_GetValue1(bkname)`

数组类型教学函数。对板块Bkname下证券代码遍历，获得每个证券当前时间的收盘价。

| 参数     | 类型   | 说明       |
| -------- | ------ | ---------- |
| `bkname` | string | 市场与板块 |

返回：array