# Builtin - 数学 / 统计与分布

## `randG(mean, std_dev)`

随机产生均值为Mean，标准差为StdDev的服从高斯分布的数据。往往用于模拟取样误差。

| 参数      | 类型 | 说明                            |
| --------- | ---- | ------------------------------- |
| `mean`    | real | 作为产生正态分布的均值          |
| `std_dev` | real | 作为产生正态分布的标准差，大于0 |

返回：real

### 示例

```tsl
return randG (2, 3);
// 结果：3.05   //3.05是均值为2,标准差为3的高斯分布的一个样本数据
```

## `gamma(x)`

计算伽马(Gamma)函数的数值

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | array | 大于0,支持数值数组。 |

返回：array

### 示例

```tsl
return gamma(array(1.5, 2.3, 3.4));
// 结果：array(0.886226925452758,1.16671190519816,2.98120642681033)
```

## `gammaln(x)`

计算对数gamma

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | array | 大于0,支持数值数组。 |

返回：array

### 示例

```tsl
return gammaln(array(1.5, 2.3, 3.4));
// 结果：array(-0.120782237635245,0.15418945495963,1.09232805980274)
```

## `erf(x)`

误差函数也称为概率函数，其定义为

| 参数 | 类型  | 说明               |
| ---- | ----- | ------------------ |
| `x`  | array | 实型变量。支持数组 |

返回：array

### 示例

```tsl
return erf(0.15);
// 结果：0.168
```

## `erfinv(x)`

误差函数逆函数

| 参数 | 类型  | 说明              |
| ---- | ----- | ----------------- |
| `x`  | array | 实型变量,支持数组 |

返回：array

### 示例

```tsl
return erfinv(0.15);
// 结果：0.13372692166482
```

## `erfc(x)`

误差累计分布函数

| 参数 | 类型  | 说明               |
| ---- | ----- | ------------------ |
| `x`  | array | 实型变量。支持数组 |

返回：array

### 示例

```tsl
return erfc(0.15);
// 0.832004028572637
```

## `erfcinv(x)`

误差累计逆函数

| 参数 | 类型  | 说明              |
| ---- | ----- | ----------------- |
| `x`  | array | 实型变量.支持数组 |

返回：array

### 示例

```tsl
return erfcinv(0.15);
// 结果：1.01790246483203
```

## `minIntValue(data)`

返回一组实数数据中的最小值的整数部分

| 参数   | 类型          | 说明                                             |
| ------ | ------------- | ------------------------------------------------ |
| `data` | array of real | 存放整数的数组，如果输入是实数，计算先取整数部分 |

返回：integer

### 示例

```tsl
a := array(5.3, 3.9, 5.6, 5, 6.5, 7.6);
return minIntValue (a);
// 结果：3
```

## `sumOfSquares(data)`

计算一组实数的平方和

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

```tsl
a := array(2, 3, 1, 5, 6.5, 7.5);
return sumOfSquares (a);
// 结果：124
```

## `sumsAndSquares(data, sum, sum_of_squares)`

计算一组实数的总和以及平方和，执行完毕后，总和存在参数Sum，平方和存在参数SumOfSquares中

| 参数             | 类型          | 说明                 |
| ---------------- | ------------- | -------------------- |
| `data`           | array of real | 存放实数的数组       |
| `sum`            | real          | 实数，用来存放总和   |
| `sum_of_squares` | real          | 实数，用来存放平方和 |

返回：any

### 示例

```tsl
a := array(2, 3, 1, 5, 6, 7);
// b是总和,c是平方和
sumsAndSquares (a, b, c);
return array(b, c);
// 输出：
// array(24.0,124.0)
```

## `maxIntValue(data)`

返回一组实数中的最大值的整数部分

| 参数   | 类型          | 说明                                               |
| ------ | ------------- | -------------------------------------------------- |
| `data` | array of real | 存放整数的数组名，如果输入是实数，计算先取整数部分 |

返回：integer

### 示例

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return maxIntValue (a);
// 结果：7
```

## `sumInt(data)`

计算一组数整数部分的总和

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放整数的数组 |

返回：integer

### 示例

```tsl
a := array(2, 3, 1, 5, 6.5, 7.5);
return sumInt(a);
// 结果：24
```

## `meanAndStdDev(data, mean, std_dev)`

估计一组数据的平均值和标准差。执行完毕后，平均值放在参数Mean中，标准差放在参数StdDev中

| 参数      | 类型          | 说明             |
| --------- | ------------- | ---------------- |
| `data`    | array of real | 实数数组         |
| `mean`    | real          | 实数，存放平均值 |
| `std_dev` | real          | 实数，存放标准差 |

返回：any

### 示例

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
// b是返回的平均值,c是返回的标准差
meanAndStdDev (a, b, c);
return array(b, c);
// 输出：
// array(5.81666666666667,1.46070759108956)
```

## `aveDev(data)`

计算一组数据与均值绝对偏差的平均值

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
// 返回数组Data的平均绝对偏
return aveDev (data);
// 结果：2.2
```

## `totalVariance(data)`

计算一组数据对其算术平均数的离差平方和（总体偏差）

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return totalVariance (a);
// 结果：10.6683333333333
```

## `median(data)`

计算一组数据的中位数

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return median (data);
// 结果：6
```

## `mode(data)`

计算一组数据的众数

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return mode(data);
// 结果：3
```

## `momentSkewKurtosis(data, m1, m2, m3, m4, skew, kurtosis)`

计算一组数据的各项统计指标

| 参数       | 类型          | 说明                       |
| ---------- | ------------- | -------------------------- |
| `data`     | array of real | 存放实数的数组             |
| `m1`       | real          | 数据平均值                 |
| `m2`       | real          | 数据的方差                 |
| `m3`       | real          | 数据的三阶中心距           |
| `m4`       | real          | 数据的四阶中心距           |
| `skew`     | real          | 偏度，反映数据不对称的程度 |
| `kurtosis` | real          | 峰度，反映数据集中的程度   |

返回：any

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
momentSkewKurtosis(data, m1, m2, m3, m4, skew, kurtosis);
return array(m1, m2, m3, m4, skew, kurtosis);
// 输出：
// array(6.42857142857143,5.95918367346938,1.25947521865896,55.6684714702205,0.0865783828574166,1.56760180146369)
```

## `devSq(data)`

计算一组数据样本平均值偏差的平方和

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return devSq(data);
// 结果：41.71
```

## `cov(data1, data2)`

两个数据间的协方差

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘的协方差
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return cov(data[: , "价格"], data[: , "大盘"]);
```

## `correl(data1, data2)`

两个数据间的相关系数

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘价格的相关系数
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return correl(data[: , "价格"], data[: , "大盘"]);
```

## `slope(data1, data2)`

两个数据间的回归斜率

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return slope(data[: , "价格"], data[: , "大盘"]);
```

## `intercept(data1, data2)`

两个数据间的回归截距

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价的相回归截距
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return intercept(data[: , "价格"], data[: , "大盘"]);
```

## `rsq(data1, data2)`

两个数据间的乘积矩相关系数平方

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘的乘积矩相关系数平方
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return rsq(data[: , "价格"], data[: , "大盘"]);
```

## `steyx(data1, data2)`

两个数据间的相对标准偏差

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘的相对标准偏差
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return steyx(data[: , "价格"], data[: , "大盘"]);
```

## `slopeandintercept(data1, data2)`

两个数据间的回归斜率和截距

| 参数    | 类型  | 说明           |
| ------- | ----- | -------------- |
| `data1` | array | 数据，一维数组 |
| `data2` | array | 数据，一维数组 |

返回：real

### 示例

```tsl
// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率和截距
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return slopeandintercept(data[: , "价格"], data[: , "大盘"]);
```

## `quartile(data, x)`

数据集中四分位的值

| 参数   | 类型          | 说明                                                                                |
| ------ | ------------- | ----------------------------------------------------------------------------------- |
| `data` | array of real | 存放实数的数组                                                                      |
| `x`    | integer       | 整数，0-4表示第几个四分点，为0的结果是数据集中最小的数，为4的结果是数据集中最大的数 |

返回：real

### 示例

```tsl
// 返回数组Data中第3个四分位数,即75%。然后按照Percentile的算法求值
// (7-1)*75%=4.5，i=4，j=5，最终结果是(1-0.5)*8+0.5*9=8.5
data := array(5, 3, 6, 8, 9, 10, 4);
return quartile(data, 3);
// 结果：8.5
```

## `minValue(data, rc, ml, assign, abnormal, fill)`

返回一组实数中的最小值

| 参数       | 类型          | 说明                                                    |
| ---------- | ------------- | ------------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                          |
| `rc`       | integer       | 可选参数，行列选择:0求列最小值；1求行最小值；默认为0    |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                          |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其最小值；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:           |
| `fill`     | any           | 可选参数，data 为空时的返回                             |

返回：real or array

### 示例

范例01：一维数组求最小值

```tsl
a := array(2, 3, 1, 5, 6, 7);
return minValue (a);
// 结果：1
```

范例02：二维数组指定列+指定步长计算最小值

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-最小"] := minValue(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.150146444095299,"B":0.0720029249787331,"A-最小":0.150146444095299),
// ("A":0.752386756474152,"B":0.794236877467483,"A-最小":0.150146444095299),
// ("A":0.875261440640315,"B":0.24984975066036,"A-最小":0.150146444095299),
// ("A":0.273097287165001,"B":0.905757479835302,"A-最小":0.150146444095299),
// ("A":0.725633884547278,"B":0.73020756803453,"A-最小":0.150146444095299),
// ("A":0.640606550732628,"B":0.688115618657321,"A-最小":0.150146444095299),
// ("A":0.942538371076807,"B":0.245572400279343,"A-最小":0.150146444095299),
// ("A":0.898009897442535,"B":0.00986421713605523,"A-最小":0.150146444095299),
// ("A":0.884120375616476,"B":0.413575921207666,"A-最小":0.150146444095299),
// ("A":0.0179871807340533,"B":0.90700996434316,"A-最小":0.0179871807340533))
```

## `maxvalue(data, rc, ml, assign, abnormal, fill)`

返回一组实数中的最大值

| 参数       | 类型          | 说明                                                    |
| ---------- | ------------- | ------------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                          |
| `rc`       | integer       | 可选参数，行列选择:0求列最大值；1求行最大值；默认为0    |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                          |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其最大值；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:           |
| `fill`     | any           | 可选参数，data 为空时的返回                             |

返回：real or array

### 示例

范例01：一维数组求最大值

```tsl
a := array(5.3, 3.9, 5.6, 5, 6.5, 7.6);
return maxValue (a);
// 结果：7.6
```

范例02：二维数组指定列+指定步长计算最大值

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-最大"] := maxValue(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.958783811656758,"B":0.707278462126851,"A-最大":0.958783811656758),
// ("A":0.750536063918844,"B":0.200482148211449,"A-最大":0.958783811656758),
// ("A":0.517184586962685,"B":0.178965070284903,"A-最大":0.958783811656758),
// ("A":0.846249950351194,"B":0.059791746083647,"A-最大":0.958783811656758),
// ("A":0.189113092375919,"B":0.773908615112305,"A-最大":0.958783811656758),
// ("A":0.789464950794354,"B":0.578314067330211,"A-最大":0.958783811656758),
// ("A":0.59376598126255,"B":0.8564029103145,"A-最大":0.958783811656758),
// ("A":0.493202868150547,"B":0.528921798337251,"A-最大":0.958783811656758),
// ("A":0.384325044928119,"B":0.3864487092942,"A-最大":0.958783811656758),
// ("A":0.977926453808323,"B":0.866223617922515,"A-最大":0.977926453808323))
```

## `mean(data, rc, ml, assign, abnormal, fill)`

计算一组数的算术平均值

| 参数       | 类型          | 说明                                                  |
| ---------- | ------------- | ----------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                        |
| `rc`       | integer       | 可选参数，行列选择:0求列平均；1求行平均；默认为0      |
| `ml`       | integer       | 可选参数，移动步长，求移动平均步长，默认不移动        |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其均值；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | 可选参数，data 为空时的返回                           |

返回：real or array

### 示例

范例01：一维数组求平均值

```tsl
a := array(2, 3, 1, 5, 6, 7);
return mean(a);
// 结果：4
```

范例02：二维数组指定列+指定步长计算平均

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-平均"] := mean(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.87071518227458,"B":0.582499709213153,"A-平均":0.87071518227458),
// ("A":0.881466222461313,"B":0.764262322103605,"A-平均":0.876090702367947),
// ("A":0.806781190447509,"B":0.855670898454264,"A-平均":0.852987531727801),
// ("A":0.999613848049194,"B":0.0568885344546288,"A-平均":0.889644110808149),
// ("A":0.481501111760736,"B":0.797956990310922,"A-平均":0.808015510998666),
// ("A":0.108187671285123,"B":0.354029157897458,"A-平均":0.691377537713076),
// ("A":0.581335202790797,"B":0.581649502040818,"A-平均":0.67565720415275),
// ("A":0.518596450332552,"B":0.212483842624351,"A-平均":0.656024609925225),
// ("A":0.639061011373997,"B":0.364532657200471,"A-平均":0.654139765641756),
// ("A":0.239243724849075,"B":0.521682396298274,"A-平均":0.612650161562488))
```

## `sum(data, rc, ml, assign, abnormal, fill)`

计算一组数的总和

| 参数       | 类型          | 说明                                                    |
| ---------- | ------------- | ------------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                          |
| `rc`       | integer       | 可选参数，行列选择:0求列的和；1求行的和；默认为0        |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                          |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其合计值；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:           |
| `fill`     | any           | 可选参数，data 为空时的返回                             |

返回：real or array

### 示例

范例01：一维数组求和

```tsl
a := array(2, 3, 1, 5, 6, 7);
return sum(a);
// 结果：24
```

范例02：二维数组指定列+指定步长求和

```tsl
arr := ones(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-累加"] := sum(arr, 0, ml, "A");
return arr;
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
```

## `norm(data, rc, ml, assign, abnormal, fill)`

计算一组数据的平方和的平方根，也就是Sqrt(SumOfSquares)

| 参数       | 类型          | 说明                                                                 |
| ---------- | ------------- | -------------------------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                                       |
| `rc`       | integer       | 可选参数，行列选择:0求列平方和的平方根；1求行平方和的平方根；默认为0 |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                                       |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其平方和的平方根；默认全部      |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:                        |
| `fill`     | any           | 可选参数，data 为空时的返回                                          |

返回：real

### 示例

范例01：一维数组求平方和的平方根

```tsl
a := array(5, 3, 5, 5, 7, 7);
return norm(a);
// 结果：13.490737563232
```

范例02：二维数组指定列+指定步长计算平方和的平方根

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-平方和的平方根"] := norm(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.183076372835785,"B":0.990034059388563,"A-平方和的平方根":0.183076372835785),
// ("A":0.251783866435289,"B":0.299099538708106,"A-平方和的平方根":0.311307040858075),
// ("A":0.49730991339311,"B":0.890515994047746,"A-平方和的平方根":0.586710510939487),
// ("A":0.0872881365939975,"B":0.574711061315611,"A-平方和的平方根":0.593168140106097),
// ("A":0.528904323000461,"B":0.131601712433621,"A-平方和的平方根":0.79472525147091),
// ("A":0.785433517768979,"B":0.914764100918546,"A-平方和的平方根":1.11736029827467),
// ("A":0.404511127155274,"B":0.0298984514083713,"A-平方和的平方根":1.18832793796699),
// ("A":0.0960042411461473,"B":0.651920047821477,"A-平方和的平方根":1.19219969068564),
// ("A":0.456138449255377,"B":0.338952687336132,"A-平方和的平方根":1.27648046885177),
// ("A":0.00426198542118073,"B":0.550133779877797,"A-平方和的平方根":1.27648758391132))
```

## `stdDev(data, rc, ml, assign, abnormal, fill)`

计算一组数据的标准差的估计（样本标准差），数学公式如下：

| 参数       | 类型          | 说明                                                         |
| ---------- | ------------- | ------------------------------------------------------------ |
| `data`     | array of real | 存放实数的数组                                               |
| `rc`       | integer       | 可选参数，行列选择:0求列样本标准差；1求行样本标准差；默认为0 |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                               |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其样本标准差；默认全部  |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:                |
| `fill`     | any           | 可选参数，data 为空时的返回                                  |

返回：real or array

### 示例

范例01：一维数组求样本标准差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return stdDev (a);
// 结果：1.46070759108956 //样本a的标准差
```

范例02：二维数组指定列+指定步长计算样本标准差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-样本标准差"] := stdDev(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.15182253299281,"B":0.315825292607769,"A-样本标准差":0.0),
// ("A":0.577175007201731,"B":0.838894178392366,"A-样本标准差":0.300769618907604),
// ("A":0.913798103574663,"B":0.327133466256782,"A-样本标准差":0.381847833237904),
// ("A":0.874265916645527,"B":0.694091119104996,"A-样本标准差":0.351970269974613),
// ("A":0.873455712106079,"B":0.718590721255168,"A-样本标准差":0.323787099621693),
// ("A":0.671421690843999,"B":0.249334673630074,"A-样本标准差":0.28961683255538),
// ("A":0.34758283989504,"B":0.831702823517844,"A-样本标准差":0.292231994406431),
// ("A":0.214012956246734,"B":0.170686958590522,"A-样本标准差":0.307933683143253),
// ("A":0.61253499193117,"B":0.52847190736793,"A-样本标准差":0.288276298285835),
// ("A":0.96317343134433,"B":0.269431800814346,"A-样本标准差":0.297346945279902))
```

## `popnStdDev(data, rc, ml, assign, abnormal, fill)`

计算一组数据的总体标准差，数学公式：

| 参数       | 类型          | 说明                                                         |
| ---------- | ------------- | ------------------------------------------------------------ |
| `data`     | array of real | 存放实数的数组                                               |
| `rc`       | integer       | 可选参数，行列选择:0求列总体标准差；1求行总体标准差；默认为0 |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                               |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其总体标准差；默认全部  |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:                |
| `fill`     | any           | 可选参数，data 为空时的返回                                  |

返回：real or array

### 示例

范例01：一维数组求总体标准差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return popnStdDev (a);
// 结果：1.33343749593131
```

范例02：二维数组指定列+指定步长计算总体标准差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-总体标准差"] := popnStdDev(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.0316496836021543,"B":0.838673108490184,"A-总体标准差":0.0),
// ("A":0.0380017445422709,"B":0.016102873487398,"A-总体标准差":0.00317603047005831),
// ("A":0.865900214761496,"B":0.421355169499293,"A-总体标准差":0.391780859156006),
// ("A":0.531020013149828,"B":0.991538721835241,"A-总体标准差":0.352314903801803),
// ("A":0.356325420551002,"B":0.24732820619829,"A-总体标准差":0.315147053389551),
// ("A":0.068206172902137,"B":0.404504089383409,"A-总体标准差":0.308162811041045),
// ("A":0.508473539724946,"B":0.705417396733537,"A-总体标准差":0.293211170252909),
// ("A":0.14910603640601,"B":0.279827648540959,"A-总体标准差":0.281654950955512),
// ("A":0.831985981203616,"B":0.0213200200814754,"A-总体标准差":0.310721312537621),
// ("A":0.0396571704186499,"B":0.384453092468903,"A-总体标准差":0.311531618685409))
```

## `variance(data, rc, ml, assign, abnormal, fill)`

计算一组数据的方差的估计（样本方差），数学公式：

| 参数       | 类型          | 说明                                                      |
| ---------- | ------------- | --------------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                            |
| `rc`       | integer       | 可选参数，行列选择:0求列样本方差；1求行样本方差；默认为0  |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                            |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其样本方差；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:             |
| `fill`     | any           | 可选参数，data 为空时的返回                               |

返回：real or array

### 示例

范例01：一维数组求样本方差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return variance (a);
// 结果：2.13366666666666
```

范例02：二维数组指定列+指定步长计算样本方差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-样本方差"] := variance(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.0976159237325191,"B":0.482796263182536,"A-样本方差":0.0),
// ("A":0.883788225706667,"B":0.639443505322561,"A-样本方差":0.309033444195665),
// ("A":0.297417941503227,"B":0.866883828537539,"A-样本方差":0.166969640815567),
// ("A":0.767699372489005,"B":0.0667955267708749,"A-样本方差":0.140455909946851),
// ("A":0.425307923927903,"B":0.222725304076448,"A-样本方差":0.106832245256288),
// ("A":0.932575504761189,"B":0.838074648519978,"A-样本方差":0.117470409113205),
// ("A":0.108969272114337,"B":0.241227929713205,"A-样本方差":0.127914790428133),
// ("A":0.345403993967921,"B":0.100473587168381,"A-样本方差":0.11270303845495),
// ("A":0.39564486593008,"B":0.465002589160577,"A-样本方差":0.0994504149628084),
// ("A":0.00122168054804206,"B":0.989088654285297,"A-样本方差":0.110630838406093))
```

## `skewness(data, rc, ml, assign, abnormal, fill)`

计算一组数据的偏度，算法和excel兼容

| 参数       | 类型          | 说明                                                  |
| ---------- | ------------- | ----------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                        |
| `rc`       | integer       | 可选参数，行列选择:0求列偏度；1求行偏度；默认为0      |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                        |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其偏度；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | 可选参数，data 为空时的返回                           |

返回：real or array

### 示例

范例01：一维数组求偏度

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return skewness (data);
// 结果：0.11
```

范例02：二维数组指定列+指定步长计算偏度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-偏度"] := skewness(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.345008506439626,"B":0.947316359030083,"A-偏度":NAN),
// ("A":0.456479304004461,"B":0.314875329611823,"A-偏度":NAN),
// ("A":0.542076414451003,"B":0.465758888283745,"A-偏度":-0.389761200780375),
// ("A":0.830417833756656,"B":0.674252083292231,"A-偏度":1.12823697245901),
// ("A":0.692654144950211,"B":0.513484538765624,"A-偏度":0.305098325022161),
// ("A":0.175067013595253,"B":0.0867823071312159,"A-偏度":-0.0145265618339346),
// ("A":0.997625324875116,"B":0.229432929540053,"A-偏度":0.131336671537343),
// ("A":0.607732360716909,"B":0.00203069648705423,"A-偏度":0.0768566639543401),
// ("A":0.769998977892101,"B":0.25457691331394,"A-偏度":-0.181274403805795),
// ("A":0.462916810531169,"B":0.490705287782475,"A-偏度":0.0103060619790022))
```

## `skewness2(data, rc, ml, assign, abnormal, fill)`

计算一组数据的偏度，算法和matlab兼容

| 参数       | 类型          | 说明                                                  |
| ---------- | ------------- | ----------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                        |
| `rc`       | integer       | 可选参数，行列选择:0求列偏度；1求行偏度；默认为0      |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                        |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其偏度；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | 可选参数，data 为空时的返回                           |

返回：real or array

### 示例

范例01：一维数组求偏度

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return skewness2(data);
// 结果：0.09
```

范例02：二维数组指定列+指定步长计算偏度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-偏度"] := skewness2(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.6100484195631,"B":0.715981872752309,"A-偏度":NAN),
// ("A":0.993454972514883,"B":0.599585968535394,"A-偏度":0.0),
// ("A":0.372750075301156,"B":0.444524445571005,"A-偏度":0.278760317564702),
// ("A":0.550206494750455,"B":0.647872807923704,"A-偏度":0.635048178529647),
// ("A":0.408510100794956,"B":0.953352153301239,"A-偏度":0.952205303351184),
// ("A":0.536475122207776,"B":0.74982732674107,"A-偏度":1.15164267581698),
// ("A":0.571144290035591,"B":0.0298545127734542,"A-偏度":1.26050077048314),
// ("A":0.230761173414067,"B":0.755714789498597,"A-偏度":0.85583534867919),
// ("A":0.150797324953601,"B":0.0688467305153608,"A-偏度":0.619687690263225),
// ("A":0.077599665382877,"B":0.990505203139037,"A-偏度":0.486284607637024))
```

## `kurtosis(data, rc, ml, assign, abnormal, fill)`

计算一组数据的峰度，算法和excel兼容

| 参数       | 类型          | 说明                                                  |
| ---------- | ------------- | ----------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                        |
| `rc`       | integer       | 可选参数，行列选择:0求列峰度；1求行峰度；默认为0      |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                        |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其峰度；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | 可选参数，data 为空时的返回                           |

返回：real or array

### 示例

范例01：一维数组计算峰度

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return kurtosis(data);
// 结果：-1.64
// 输出：-1.64
```

范例02：二维数组指定列+指定步长计算峰度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-峰度"] := kurtosis(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.980047498596832,"B":0.402004413306713,"A-峰度":NAN),
// ("A":0.633000277215615,"B":0.990959876682609,"A-峰度":NAN),
// ("A":0.0302784142550081,"B":0.897569506429136,"A-峰度":NAN),
// ("A":0.952995504485443,"B":0.902370758820325,"A-峰度":1.14914121941789),
// ("A":0.647436241386458,"B":0.798524161800742,"A-峰度":1.75277777253052),
// ("A":0.106838567415252,"B":0.783145941328257,"A-峰度":-1.79403146968547),
// ("A":0.940166180720553,"B":0.361717429943383,"A-峰度":-1.27336988351427),
// ("A":0.696889952989295,"B":0.985664031002671,"A-峰度":-0.658650953176948),
// ("A":0.123242125613615,"B":0.675423074513674,"A-峰度":-1.65506451391199),
// ("A":0.986539963865653,"B":0.68698396300897,"A-峰度":-1.41423021480228))
```

## `kurtosis2(data, rc, ml, assign, abnormal, fill)`

计算一组数据的峰度，算法和matlab兼容

| 参数       | 类型          | 说明                                                  |
| ---------- | ------------- | ----------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                        |
| `rc`       | integer       | 可选参数，行列选择:0求列峰度；1求行峰度；默认为0      |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                        |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其峰度；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | 可选参数，data 为空时的返回                           |

返回：real

### 示例

范例01：：一维数组计算峰度

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return kurtosis2(data);
// 结果：1.57
```

范例02：二维数组指定列+指定步长计算峰度

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-峰度"] := kurtosis2(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.655130569823086,"B":0.169059717329219,"A-峰度":NAN),
// ("A":0.848595677409321,"B":0.331126981182024,"A-峰度":1.00000000000272),
// ("A":0.0950429700314999,"B":0.555930029833689,"A-峰度":1.5),
// ("A":0.741949734743685,"B":0.7052144294139,"A-峰度":2.19701539579311),
// ("A":0.0635894564911723,"B":0.696825876133516,"A-峰度":1.23130776662201),
// ("A":0.975331973750144,"B":0.707070349482819,"A-峰度":1.52458726295925),
// ("A":0.199741119518876,"B":0.772686692187563,"A-峰度":1.30375485345706),
// ("A":0.133859496098012,"B":0.414379859110341,"A-峰度":1.27199062552285),
// ("A":0.402421594597399,"B":0.580620889784768,"A-峰度":1.43616776036497),
// ("A":0.465525532606989,"B":0.129364971769974,"A-峰度":1.59328967992336))
```

## `harmean(data, rc, ml, assign, abnormal, fill)`

计算一组数据的调和平均数

| 参数       | 类型          | 说明                                                         |
| ---------- | ------------- | ------------------------------------------------------------ |
| `data`     | array of real | 存放实数的数组                                               |
| `rc`       | integer       | 可选参数，行列选择:0求列调和平均数；1求行调和平均数；默认为0 |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                               |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其调和平均数；默认全部  |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:                |
| `fill`     | any           | 可选参数，data 为空时的返回                                  |

返回：real or array

### 示例

范例01：一维数组计算调和平均数

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return harmean(data);
// 结果：5.44
```

范例02：二维数组指定列+指定步长计算调和平均数

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-调和平均数"] := harmean(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.124961190624163,"B":0.0598194859921932,"A-调和平均数":0.124961190624163),
// ("A":0.857839953387156,"B":0.141636071261019,"A-调和平均数":0.218145252665682),
// ("A":0.65432970575057,"B":0.0625838069245219,"A-调和平均数":0.280465973816327),
// ("A":0.458887472050265,"B":0.121089172083885,"A-调和平均数":0.310663488719166),
// ("A":0.613102434901521,"B":0.116132015362382,"A-调和平均数":0.344667921602947),
// ("A":0.785793515155092,"B":0.855155329685658,"A-调和平均数":0.380244620081035),
// ("A":0.799667620798573,"B":0.722903371788561,"A-调和平均数":0.411043312484736),
// ("A":0.653244619490579,"B":0.679718399886042,"A-调和平均数":0.431019257240658),
// ("A":0.955700401915237,"B":0.652552865445614,"A-调和平均数":0.459019535579044),
// ("A":0.965912215644494,"B":0.150117957498878,"A-调和平均数":0.484442154536813))
```

## `product(data, rc, ml, assign, abnormal, fill)`

返回累乘值

| 参数       | 类型          | 说明                                                    |
| ---------- | ------------- | ------------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                          |
| `rc`       | integer       | 可选参数，行列选择:0求列累乘值；1求行累乘值；默认为0    |
| `ml`       | integer       | 可选参数，移动步长，默认不移动                          |
| `assign`   | integer       | 可选参数，对字段筛选,指定某些行列，求其累乘值；默认全部 |
| `abnormal` | integer       | 可选参数，异常处理参数，按照存储位来进行管理:           |
| `fill`     | any           | 可选参数，data 为空时的返回                             |

返回：real or array

### 示例

```tsl
// 一维数组计算累乘值
data := array(5, 3, 6, 8, 9, 10, 4);
return product (data);
// 结果：259200 //返回5*3*6*8*9*10*4
```

范例02：二维数组指定列+指定步长计算累乘值

```tsl
arr := rand(10, array("A", "B")) * 10;
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-累乘"] := product(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":3.50745165487751,"B":8.34431231953204,"A-累乘":3.50745165487751),
// ("A":6.7908460390754,"B":5.874217399396,"A-累乘":23.8185641777734),
// ("A":5.74234192026779,"B":0.828072652220726,"A-累乘":136.774339558617),
// ("A":4.92611460620537,"B":0.982504128478467,"A-累乘":673.766071853797),
// ("A":2.6915419078432,"B":8.85313867591322,"A-累乘":1813.46961847739),
// ("A":2.64794702874497,"B":3.58003713656217,"A-累乘":4801.97148796647),
// ("A":5.65035830019042,"B":3.64946177229285,"A-累乘":27132.8594543091),
// ("A":7.37319005886093,"B":4.58649940323085,"A-累乘":200055.729596983),
// ("A":5.89445208897814,"B":2.48157736845315,"A-累乘":1179218.91323498),
// ("A":7.35567317577079,"B":2.42680004332215,"A-累乘":8673948.92844412))
```

## `large(data, n, rc, ml, assign, abnormal, fill)`

找出第N最大的数

| 参数       | 类型          | 说明                                                 |
| ---------- | ------------- | ---------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                       |
| `n`        | integer       | 表示序号，1表示最大的数据                            |
| `rc`       | integer       | 行列选择:0求列第N最大的数；1求行第N最大的数；默认为0 |
| `ml`       | integer       | 移动步长，默认不移动                                 |
| `assign`   | integer       | 对字段筛选,指定某些行列，求其第N最大的数；默认全部   |
| `abnormal` | integer       | 异常处理参数，按照存储位来进行管理:                  |
| `fill`     | any           | data 为空时的返回                                    |

返回：real

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
// 返回数组Data中第3大的数据
return large (data, 3);
// 结果：8
```

## `small(data, n, rc, ml, assign, abnormal, fill)`

找出第N最小的数

| 参数       | 类型          | 说明                                                 |
| ---------- | ------------- | ---------------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                       |
| `n`        | integer       | 表示序号，1表示最小的数据                            |
| `rc`       | integer       | 行列选择:0求列第N最小的数；1求行第N最小的数；默认为0 |
| `ml`       | integer       | 移动步长，默认不移动                                 |
| `assign`   | integer       | 对字段筛选,指定某些行列，求其第N最小的数；默认全部   |
| `abnormal` | integer       | 异常处理参数，按照存储位来进行管理:                  |
| `fill`     | any           | data 为空时的返回                                    |

返回：real

### 示例

```tsl
// 返回数组Data中第3小的数据
data := array(5, 3, 6, 8, 9, 10, 4);
return small (data, 3);
// 结果：5
```

## `percentrank(data, x, rc, ml, assign, abnormal, fill)`

数据集中X在该组数据中的百分点

| 参数       | 类型          | 说明                                          |
| ---------- | ------------- | --------------------------------------------- |
| `data`     | array of real | 存放实数的数组                                |
| `x`        | real          | 实数，在数据集外的数的百分位使用线性插值得到  |
| `rc`       | integer       | 行列选择:0求列百分点；1求行百分点；默认为0    |
| `ml`       | integer       | 移动步长，默认不移动                          |
| `assign`   | integer       | 对字段筛选,指定某些行列，求其百分点；默认全部 |
| `abnormal` | integer       | 异常处理参数，按照存储位来进行管理:           |
| `fill`     | any           | data 为空时的返回                             |

返回：real

### 示例

```tsl
// 返回8在数组Data的百分点，即小于8的个数/（小于8个数+大于8个
// 数）结果是4/6
data := array(5, 3, 6, 8, 9, 10, 4);
return percentrank(data, 8);
// 结果：0.666666666666667
```

## `rank(data, x, rc, ml, assign, abnormal, fill)`

返回X在DATA中的排名(Data从大到小排列)，该数据必需存在在Data中。

| 参数       | 类型          | 说明                                        |
| ---------- | ------------- | ------------------------------------------- |
| `data`     | array of real | 存放实数的数组                              |
| `x`        | real          | 实数                                        |
| `rc`       | integer       | 行列选择:0求列排名；1求行排名；默认为0      |
| `ml`       | integer       | 移动步长，默认不移动                        |
| `assign`   | integer       | 对字段筛选,指定某些行列，求其排名；默认全部 |
| `abnormal` | integer       | 异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | data 为空时的返回                           |

返回：real

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return rank(data, 8);
// 结果：3
```

## `trimmean(data, x, rc, ml, assign, abnormal, fill)`

返回去掉头尾百分数以后的平均值。算法如下：

| 参数       | 类型          | 说明                                        |
| ---------- | ------------- | ------------------------------------------- |
| `data`     | array of real | 存放实数的数组                              |
| `x`        | real          | 百分比，实数，一般在0-1之间                 |
| `rc`       | integer       | 行列选择:0求列排名；1求行排名；默认为0      |
| `ml`       | integer       | 移动步长，默认不移动                        |
| `assign`   | integer       | 对字段筛选,指定某些行列，求其排名；默认全部 |
| `abnormal` | integer       | 异常处理参数，按照存储位来进行管理:         |
| `fill`     | any           | data 为空时的返回                           |

返回：real

### 示例

```tsl
// 去除个数=总个数7*0.7=4.9，头和尾各去除2个数据，剩下数据5，6，8求//均值
data := array(5, 3, 6, 8, 9, 10, 4);
return trimmean(data, 0.7);
// 结果：6.33333333333333
```

## `frequency(data, freq_data, rc, ml, assign, abnormal, fill)`

返回DATA在FreqData分割区间中的出现个数。

| 参数        | 类型          | 说明                                                                                                    |
| ----------- | ------------- | ------------------------------------------------------------------------------------------------------- |
| `data`      | array of real | 存放实数的数组                                                                                          |
| `freq_data` | array of real | 分割区间，如果为array(1,2,3)则表示需要计算Data 分别落在(-inf,1),(1,2),(2,3),(3,inf)四个区间的个数(频数) |
| `rc`        | integer       | 行列选择:0求列排名；1求行排名；默认为0                                                                  |
| `ml`        | integer       | 移动步长，默认不移动                                                                                    |
| `assign`    | integer       | 对字段筛选,指定某些行列，求其排名；默认全部                                                             |
| `abnormal`  | integer       | 异常处理参数，按照存储位来进行管理:                                                                     |
| `fill`      | any           | data 为空时的返回                                                                                       |

返回：array of integer

### 示例

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
freq_data := array(1, 2, 3);
return frequency(data, freq_data);
// 输出：
// array(0,0,1,6)
```

## `geomean(data)`

计算一组数据的几何平均数

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

范例01：一维数组计算几何平均数

```tsl
data := array(5, 3, 6, 8, 9, 10, 4);
return geomean (data);
// 结果：5.93
```

范例02：二维数组指定列+指定步长计算几何平均数

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-几何平均数"] := geomean(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.519830256002024,"B":0.374670889694244,"A-几何平均数":0.519830256002024),
// ("A":0.765975012211129,"B":0.00843984819948673,"A-几何平均数":0.631012667613626),
// ("A":0.402682410785928,"B":0.294473465066403,"A-几何平均数":0.543266516297067),
// ("A":0.66125158383511,"B":0.80891461763531,"A-几何平均数":0.570625775662063),
// ("A":0.239383002044633,"B":0.718946079257876,"A-几何平均数":0.479622744628361),
// ("A":0.335142631782219,"B":0.669408179819584,"A-几何平均数":0.451808871517444),
// ("A":0.664034612709656,"B":0.788084068801254,"A-几何平均数":0.477359539816948),
// ("A":0.0850369480904192,"B":0.813925041817129,"A-几何平均数":0.384760839429897),
// ("A":0.231962512480095,"B":0.205027454067022,"A-几何平均数":0.363723728819524),
// ("A":0.809202993987128,"B":0.396649306640029,"A-几何平均数":0.394003626650774))
```

## `popnVariance(data)`

计算一组数据的总体方差，数学公式：

| 参数   | 类型          | 说明           |
| ------ | ------------- | -------------- |
| `data` | array of real | 存放实数的数组 |

返回：real

### 示例

范例01：一维数组求总体方差

```tsl
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return popnVariance(a);
// 结果：1.77805555555555
```

范例02：二维数组指定列+指定步长计算总体方差

```tsl
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-总体方差"] := popnVariance(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.564295332413167,"B":0.198089802404866,"A-总体方差":0.0),
// ("A":0.166125119663775,"B":0.0624075580853969,"A-总体方差":0.039634879580224),
// ("A":0.378304088953883,"B":0.14998382772319,"A-总体方差":0.0264613528859377),
// ("A":0.318244896829128,"B":0.703246884280816,"A-总体方差":0.0203400328742531),
// ("A":0.568663859274238,"B":0.957403063541278,"A-总体方差":0.0234577418324268),
// ("A":0.257466434501112,"B":0.0300985530484468,"A-总体方差":0.0223352875445233),
// ("A":0.957228042650968,"B":0.674682865617797,"A-总体方差":0.0605798191589568),
// ("A":0.73080830834806,"B":0.904764427104965,"A-总体方差":0.0611106539800822),
// ("A":0.236550874542445,"B":0.432319020619616,"A-总体方差":0.0607978820394406),
// ("A":0.479372498579323,"B":0.225869641872123,"A-总体方差":0.0547388465767192))
```

## `percentile(data, pct, rc, ml, assign, abnormal, fi_ll)`

计算序列百分点PCT的值。

| 参数       | 类型                   | 说明                                                                            |
| ---------- | ---------------------- | ------------------------------------------------------------------------------- |
| `data`     | array of real          | 数组，存放实数的数组                                                            |
| `pct`      | real                   | 实数，表示百分点,从0开始,以1结束                                                |
| `rc`       | integer                | 行列选择:0求列第PCT个百分点的值；1求行第PCT个百分点的值；默认为0                |
| `ml`       | integer                | 整型，移动步长，取当前行向前ML个长度序列的百分点的值，为0时取整个序列（默认）。 |
| `assign`   | integer\|string\|array | 下标或下标序列，对字段筛选，指定某些行列求百分点的值，为nil时为全部（默认）。   |
| `abnormal` | integer                | 整型，                                                                          |
| `fi_ll`    | any                    | 数据data为空时的返回值。                                                        |

返回：real

### 示例

范例1：序列百分点的值

```tsl
// 返回数组Data的第3个百分点
data := array(5, 3, 6, 8, 9, 10, 4);
return percentile(data, 0.3);
// 结果：4.8
```

范例2：二维数组各列百分点的值

```tsl
a := array('A': ('g': 1, 'f': 2, 'k': 3),
'B': ('g': 10, 'f': 20, 'k': 30),
'C': ('g': 100, 'f': 200, 'k': 300),
'D': ('g': 1000, 'f': 2000, 'k': 3000),
);
return percentile(a, 0.5, 0);
```

范例3：二维数组指定列指定步长的百分点的值

```tsl
a := array('A': ('g': 1, 'f': 2, 'k': 3),
'B': ('g': 10, 'f': 20, 'k': 30),
'C': ('g': 100, 'f': 200, 'k': 300),
'D': ('g': 1000, 'f': 2000, 'k': 3000),
);
return percentile(a, 0.5, 0, 2, array('f', 'k'));
```

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

## `std(rsp_cycle, n)`

已实现波动率(%)

| 参数        | 类型 | 说明                                                                                                                                        |
| ----------- | ---- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rsp_cycle` | any  | 采样小周期                                                                                                                                  |
| `n`         | any  | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |

返回：float

## `stdUp(rsp_cycle, n)`

高频上行波动率(%)

| 参数        | 类型 | 说明                                                                                                                                        |
| ----------- | ---- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rsp_cycle` | any  | 采样小周期                                                                                                                                  |
| `n`         | any  | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |

返回：float

## `beta(rsp_cycle, n, cut_value)`

S=|R|/(V^beta)

| 参数        | 类型  | 说明                                                                                                                                        |
| ----------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rsp_cycle` | any   | 采样小周期                                                                                                                                  |
| `n`         | any   | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
| `cut_value` | float | 划分截至比例                                                                                                                                |

返回：float

## `lnv(rsp_cycle, n, cut_value)`

S=|R|/ln(V)

| 参数        | 类型  | 说明                                                                                                                                        |
| ----------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rsp_cycle` | any   | 采样小周期                                                                                                                                  |
| `n`         | any   | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
| `cut_value` | float | 划分截至比例                                                                                                                                |

返回：float

## `skewWBuy(rsp_cycle, k, n)`

净委买变化率偏度

| 参数        | 类型 | 说明                                                                                                                                        |
| ----------- | ---- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `rsp_cycle` | any  | 采样小周期                                                                                                                                  |
| `k`         | any  | 前k档行情，默认为1                                                                                                                          |
| `n`         | any  | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |

返回：float

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

## `sf_exppdf(values, lambda_value)`

计算指数分布概率密度。

| 参数           | 类型  | 说明                                                       |
| -------------- | ----- | ---------------------------------------------------------- |
| `values`       | array | 随机变量序列；标量输入会返回 `nil`，生成代码时使用数组输入 |
| `lambda_value` | float | lambda 参数                                                |

返回：array

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

## `randgam(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 randgam(2, 2, 100, array("a", "b"));
// 输出：
// Execute script error at Line:1
// function:__main__:line 1:instruction:array: function:randgam compile error or not found
// function:__main__:line 1:instruction:array: function execute error
```

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

## `sf_expcdf(values, lambda_value)`

计算指数分布累计分布值。

| 参数           | 类型  | 说明                                                       |
| -------------- | ----- | ---------------------------------------------------------- |
| `values`       | array | 随机变量序列；标量输入会返回 `nil`，生成代码时使用数组输入 |
| `lambda_value` | float | lambda 参数                                                |

返回：array

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

## `sf_betapdf(x, shape_alpha, shape_beta)`

计算 Beta 分布概率密度。

| 参数          | 类型  | 说明           |
| ------------- | ----- | -------------- |
| `x`           | array | 随机变量值     |
| `shape_alpha` | float | alpha 形状参数 |
| `shape_beta`  | float | beta 形状参数  |

返回：array

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

## `sf_mvtcdf(lower_bounds, upper_bounds, correlation_matrix, degrees_freedom)`

计算多变量 t 分布累计分布值。

| 参数                 | 类型  | 说明                            |
| -------------------- | ----- | ------------------------------- |
| `lower_bounds`       | array | 下界；传 `nil` 表示使用默认下界 |
| `upper_bounds`       | array | 上界矩阵                        |
| `correlation_matrix` | array | 相关系数矩阵                    |
| `degrees_freedom`    | float | 自由度                          |

返回：array

## `sf_mvncdf(lower_bounds, upper_bounds, mean_values, correlation_matrix)`

计算多变量正态分布累计分布值。

| 参数                 | 类型  | 说明                            |
| -------------------- | ----- | ------------------------------- |
| `lower_bounds`       | array | 下界；传 `nil` 表示使用默认下界 |
| `upper_bounds`       | array | 上界矩阵                        |
| `mean_values`        | array | 均值；传 `nil` 表示使用默认均值 |
| `correlation_matrix` | array | 相关系数矩阵                    |

返回：array

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

正态逆函数

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

返回：float | array

### 示例

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

## `correlationMatrix(a1, t)`

相关系数矩阵求解

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

返回：array

### 示例

```tsl
a := rand(4, 3);
return correlationMatrix(a, 1);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall:  函数 CorrelationMatrix : 参数不匹配！
// function:__main__:line 2:instruction:usercall: function execute error
// function:__main__:line 2:instruction:usercall: function execute error
```

## `covariance()`

计算协方差矩阵

返回：any

### 示例

```tsl
a := rand(4, 3);
return covariance(a);
// 输出：
// Execute script error at Line:2
// function:__main__:line 2:instruction:usercall: function:covariance compile error or not found
// function:__main__:line 2:instruction:usercall: function execute error
```

## `Corr_partial(x_values, y_values, z_values, method, tail)`

计算偏相关系数；带 `tail` 时同时返回检验结果。

| 参数       | 类型   | 说明                                         |
| ---------- | ------ | -------------------------------------------- |
| `x_values` | array  | 第一组变量                                   |
| `y_values` | array  | 第二组变量                                   |
| `z_values` | array  | 控制变量                                     |
| `method`   | any    | 相关系数计算方式                             |
| `tail`     | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |

返回：array

## `factor(x, var_value)`

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

| 参数        | 类型          | 说明                                |
| ----------- | ------------- | ----------------------------------- |
| `x`         | array of real | 二维维实数数组，表示样本矩阵；      |
| `var_value` | real          | 实数，表示方差贡献率,控制因子个数； |

返回：array

### 示例

```tsl
// 我们对2010年上证A股的9个财务指标进行因子分析：
// 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); //
return br;
// 输出：分析：
Ret["kmo", 0]=0.733，即表明数据可以做因子分析
ret["Total Variance Explained", 0]：第一列为样本矩阵的相关系数矩阵的特征值，第二列为方差贡献率，第三列为累计方差贡献率
ret["Component Matrix", 0]：因子载荷矩阵
ret["Communalities", 0]：共同度表示三个因子解释掉变量的多少，显然，共同度越大，表示能解释原来变量的信息就越全；
ret["thogonal matrix", 0]：从thogonal matrix中看出第一个公因子可以解释为“规模因子”，因为它的 0: 主营业务收入净额、1: 主营业务利润;、2: 利润总额、3: 净利润、7: 资产总计、8: 股本的绝对值都比较大；第二个公因子可以解释为“收益率因子”，因为其4: 每股收益、5: 每股净资产的绝对值大；第三个公因子则可以解释为“每股价值因子”因为其4: 每股收益和6: 净资产收益率;的绝对值较大。因子分析模型中的因子是抽象的，得根据研究对象的具体分析所解释，“解释”是抽象的概念。
ret["Rotation matrix", 0]：旋转矩阵
array(
(0.9888, 0.1296, 0.0734),
(-0.149, 0.8703, 0.4695),
(-0.0031, -0.4752, 0.8799))
ret["Factor score", 0]: 因子得分，表示各个股票在这三个因子的得分情况，让研究人员更好的做其他分析
```

## `corr_Kendall(x_values, y_values)`

计算 Kendall 秩相关系数。

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

返回：float

## `histc(a, b)`

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

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

返回：array

### 示例

```tsl
a := rand(1000) * 5;
b := array(0, 1, 2, 3, 4, 5);
return histc(a, b);
// 输出：
// Execute script error at Line:3
// function:__main__:line 3:instruction:usercall: function:histc compile error or not found
// function:__main__:line 3:instruction:usercall: function execute error
```

## `Regress_domin_formula(y_values, x_values)`

计算回归解释变量的相对重要性。

| 参数       | 类型  | 说明           |
| ---------- | ----- | -------------- |
| `y_values` | array | 因变量样本     |
| `x_values` | array | 自变量样本矩阵 |

返回：array

## `Regress_DWTest(residuals)`

计算 Durbin-Watson 统计量。

| 参数        | 类型  | 说明         |
| ----------- | ----- | ------------ |
| `residuals` | array | 回归残差序列 |

返回：float

## `Regress_MLS(y_values, x_values, residuals)`

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

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

返回：array

## `Regress_CMLS(y_values, x_values, residuals, constant)`

执行带常数项控制的最小二乘回归并输出残差。

| 参数        | 类型  | 说明           |
| ----------- | ----- | -------------- |
| `y_values`  | array | 因变量样本     |
| `x_values`  | array | 自变量样本矩阵 |
| `residuals` | any   | 接收残差序列   |
| `constant`  | any   | bool           |

返回：array

## `Regression_OLS_NW(y_values, x_values)`

执行普通最小二乘回归，并输出 Newey-West 稳健标准误相关结果。

| 参数       | 类型  | 说明           |
| ---------- | ----- | -------------- |
| `y_values` | array | 因变量样本     |
| `x_values` | array | 自变量样本矩阵 |

返回：array

## `Regress_TTest_RWLS(x_values, coefficients, residuals, variable_count, alpha, constant)`

执行线性约束加权最小二乘回归的系数 T 检验。

| 参数             | 类型  | 说明                       |
| ---------------- | ----- | -------------------------- |
| `x_values`       | array | 自变量样本                 |
| `coefficients`   | array | 回归系数                   |
| `residuals`      | array | 回归残差序列               |
| `variable_count` | any   | 自变量数量或自由度相关参数 |
| `alpha`          | float | 显著性水平                 |
| `constant`       | any   | bool                       |

返回：array

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

执行 GRS 检验。

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

返回：array

## `Hypoth_SNUTest(values, mean_value, std_dev, tail, alpha)`

执行单个正态总体均值 U 检验。

| 参数         | 类型   | 说明                                         |
| ------------ | ------ | -------------------------------------------- |
| `values`     | array  | 样本数据                                     |
| `mean_value` | float  | 原假设均值                                   |
| `std_dev`    | float  | 总体标准差                                   |
| `tail`       | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`      | float  | 显著性水平                                   |

返回：array

## `Hypoth_TNUTest(samples, mean_diff, std_devs, tail, alpha, mode)`

执行两个正态总体均值差 U 检验。

| 参数        | 类型   | 说明                                         |
| ----------- | ------ | -------------------------------------------- |
| `samples`   | array  | 两组样本数据                                 |
| `mean_diff` | float  | 原假设均值差                                 |
| `std_devs`  | array  | 两组标准差参数                               |
| `tail`      | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`     | float  | 显著性水平                                   |
| `mode`      | any    | 检验模式参数                                 |

返回：array

## `Hypoth_SNDTest(values, variance_value, tail, alpha)`

执行单个正态总体方差检验。

| 参数             | 类型   | 说明                                         |
| ---------------- | ------ | -------------------------------------------- |
| `values`         | array  | 样本数据                                     |
| `variance_value` | float  | 原假设方差                                   |
| `tail`           | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`          | float  | 显著性水平                                   |

返回：array

## `Hypoth_TNDTest(samples, tail, alpha)`

执行两个正态总体方差检验。

| 参数      | 类型   | 说明                                         |
| --------- | ------ | -------------------------------------------- |
| `samples` | array  | 两组样本数据                                 |
| `tail`    | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`   | float  | 显著性水平                                   |

返回：array

## `Hypoth_LSUTest(sample_mean, sample_variance, sample_count, mean_value, tail, alpha)`

用样本均值、样本方差和样本数量执行单总体均值检验。

| 参数              | 类型   | 说明                                         |
| ----------------- | ------ | -------------------------------------------- |
| `sample_mean`     | float  | 样本均值                                     |
| `sample_variance` | float  | 样本方差                                     |
| `sample_count`    | any    | 样本数量                                     |
| `mean_value`      | float  | 原假设均值                                   |
| `tail`            | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`           | float  | 显著性水平                                   |

返回：array

## `Anova_Single(groups, alpha)`

执行单因素方差分析。

| 参数     | 类型  | 说明       |
| -------- | ----- | ---------- |
| `groups` | array | 各组观测值 |
| `alpha`  | float | 显著性水平 |

返回：array

## `Anova_Twice(values, alpha, repeat_count)`

执行双因素方差分析。

| 参数           | 类型  | 说明                           |
| -------------- | ----- | ------------------------------ |
| `values`       | array | 观测值矩阵                     |
| `alpha`        | float | 显著性水平                     |
| `repeat_count` | any   | 每个因素水平组合的重复试验次数 |

返回：array

## `Anova_Levene(groups, alpha)`

执行 Levene 方差齐性检验。

| 参数     | 类型  | 说明       |
| -------- | ----- | ---------- |
| `groups` | array | 各组观测值 |
| `alpha`  | float | 显著性水平 |

返回：array

## `Hypoth_SignTest(values, probability, median_value, tail, alpha)`

执行符号检验。

| 参数           | 类型   | 说明                                         |
| -------------- | ------ | -------------------------------------------- |
| `values`       | array  | 样本数据                                     |
| `probability`  | float  | 原假设成功概率                               |
| `median_value` | float  | 原假设中位数                                 |
| `tail`         | string | 检验方向；常用 `"both"`、`"left"`、`"right"` |
| `alpha`        | float  | 显著性水平                                   |

返回：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
```

## `correlpaired(a, b)`

功能：计算 a 的每一列与 b 的每一列之间的相关系数矩阵，

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

返回：array

### 示例

范例01

```tsl
a := rand(10);
b := rand(10);
return correlpaired(a, b); // array((0.17))
```

范例02

```tsl
a := rand(10);
b := rand(10, 2);
return correlpaired(a, b); // array((-0.35,-0.19))
```

范例03

```tsl
a := rand(10, 2);
b := rand(10, 4);
return correlpaired(a, b);
// 返回:
```

范例04

```tsl
a := `array("A": rand(10));
b := `array("A": rand(10), "B": rand(10));
return correlpaired(a, b); // array((0.2,-0.08))
```

## `correlpaired_side(a, dir_type)`

功能：计算 a 的每两列之间符合对应过滤条件的相关系数矩阵， 1) +-相关系数 ：将 a <0 的元素替换为0 ，b>0的元素替换为0,计算相关系数 2) 同向相关系数 ：将 a 与 b 非同向（乘积<0）的元素替换为0，计算相关系数 场景支持同 correlpaired 内部强制 a 转化为fmarray进行计算

| 参数       | 类型  | 说明                |
| ---------- | ----- | ------------------- |
| `a`        | array | 一维数字数组,       |
| `dir_type` | any   | 用户自定义,方向类型 |

返回：array

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

## `sf_SinX(x, v)`

正弦积分的定义为

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。自变量     |
| `v`  | float | 实型变量，返回的结果 |

返回：any

## `sf_CosX(x, v)`

余弦积分的定义为

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。自变量     |
| `v`  | float | 实型变量，返回的结果 |

返回：any

## `sf_eX(x, v)`

指数积分的定义为

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。自变量     |
| `v`  | float | 实型变量，返回的结果 |

返回：any

## `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_Gamma(x, v)`

计算伽马(Gamma)函数的数值 伽马(Gamma)函数的定义为

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。要求X>=0   |
| `v`  | float | 实型变量，返回的结果 |

返回：any

## `sf_Beta(x, y, v)`

计算贝塔函数(Beta)的数值，贝塔函数(Beta)的定义为 或者：

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。要求X>=0   |
| `y`  | float | 实型变量。要求Y>=0   |
| `v`  | float | 实型变量，返回的结果 |

返回：any

## `sf_Error(x, v)`

误差函数也称为概率函数，其定义为

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。要求X>=0   |
| `v`  | float | 实型变量，返回的结果 |

返回：any

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

正态分布函数的定义为 其中： (1)a为随机变量的数学期望（平均值） (2)σ为随机变量的标准差

| 参数 | 类型  | 说明                 |
| ---- | ----- | -------------------- |
| `x`  | float | 实型变量。随机变量值 |
| `a`  | float | 实型变量。数学期望值 |
| `d`  | float | 实型变量。标准值     |

返回：any

## `sf_normalinv(data, m, s, v)`

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

| 参数   | 类型  | 说明                                                       |
| ------ | ----- | ---------------------------------------------------------- |
| `data` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `m`    | float | 正态分布参数，均值，实数类型                               |
| `s`    | float | 正态分布参数，标准差，实数类型                             |
| `v`    | array | 随机变量值，变参返回。                                     |

返回：any

## `sf_normalinv2(data, v)`

标准正态分布的分布逆函数，输入分布函数或者累计概率值，得到随机变量值

| 参数   | 类型  | 说明                                                       |
| ------ | ----- | ---------------------------------------------------------- |
| `data` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `v`    | array | 随机变量值，变参返回。                                     |

返回：any

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

## `sf_nbininv(y, r, p, x)`

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

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

返回：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_tinv(data, n, v)`

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

| 参数   | 类型  | 说明                                                         |
| ------ | ----- | ------------------------------------------------------------ |
| `data` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
| `n`    | any   | 整数，自由度。                                               |
| `v`    | array | 实数，随机变量值，变参返回。                                 |

返回：any

## `sf_finv(data, n, n1, v)`

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

| 参数   | 类型  | 说明                                                         |
| ------ | ----- | ------------------------------------------------------------ |
| `data` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
| `n`    | any   | 整数，分子自由度。                                           |
| `n1`   | any   | 整数，分母自由度。                                           |
| `v`    | array | 实数，随机变量值，变参返回。                                 |

返回：any

## `sf_x2inv(data, n, v)`

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

| 参数   | 类型  | 说明                                                         |
| ------ | ----- | ------------------------------------------------------------ |
| `data` | array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
| `n`    | any   | 自由度。                                                     |
| `v`    | array | 随机变量值，变参返回。                                       |

返回：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_gammainv(probability, alpha, v)`

标准gamma分布的逆函数，输入分布函数或者累计概率值，返回随机变量值。功能等同于sf_gaminv(Probability, Alpha,1,v)。

| 参数          | 类型 | 说明                                                         |
| ------------- | ---- | ------------------------------------------------------------ |
| `probability` | any  | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
| `alpha`       | any  | Alpha分布参数。                                              |
| `v`           | any  | 随机变量值，变参返回                                         |

返回：any

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

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

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

返回：any

## `sf_betainv(y, a, b, x)`

贝塔分布的分布逆函数，输入分布函数值，输出随机变量值

| 参数 | 类型  | 说明                                                        |
| ---- | ----- | ----------------------------------------------------------- |
| `y`  | array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
| `a`  | float | beta分布参数1,实数,大于0                                    |
| `b`  | float | beta分布参数2,实数,大于0                                    |
| `x`  | array | 变参返回，类型和y一样                                       |

返回：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

## `mvtcdfqmc(a, b, rho, nu, options, funevals)`

中间函数，采用蒙特卡洛计算多元t分布，估计概率P值以及误差

| 参数       | 类型  | 说明                                         |
| ---------- | ----- | -------------------------------------------- |
| `a`        | array | 数组，下限，可省略，默认为负无穷             |
| `b`        | array | 数组，下限或实际需计算分布的样本值，不可省略 |
| `rho`      | array | 数组，相关系数矩阵                           |
| `nu`       | float | 实数，自由度                                 |
| `options`  | array | 数组，规划条件设置                           |
| `funevals` | array | 线性回归的结果条件                           |

返回：array

### 示例

范例01：

```tsl
rho := array(
(1, 0.923912552224476, 0.035770327030089),
(0.923912552224476, 1, 0.084276570941762),
(0.035770327030089, 0.084276570941762, 1)
);
return mvtcdfqmc(array(0, 0, 0), rand(3), rho, 2, array());
```

## `sf_copulacdf(x, copula_type, rho, alpha, options)`

估计多元函数分布值

| 参数          | 类型   | 说明                                                                                                                 |
| ------------- | ------ | -------------------------------------------------------------------------------------------------------------------- |
| `x`           | array  | 数组，样本值为均匀分布需要在\[0,1\]区间内，至少2维                                                                   |
| `copula_type` | string | 字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维               |
| `rho`         | array  | 数组，相关系数矩阵，d\*d                                                                                             |
| `alpha`       | float  | 实数，参数估计值，t分布时为自由度，二元阿基米德分布时为估值参数,默认1;；clayton:\[0,∞)； frank:(-∞,∞)；gumbel:\[1,∞) |
| `options`     | array  | 数组，估计规划条件，可为空                                                                                           |

返回：array

## `sf_copulafit(x, copula_type, method, options)`

估计多元分布相关系数矩阵

| 参数          | 类型   | 说明                                                                                                                          |
| ------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------- |
| `x`           | array  | 数组，样本值为均匀分布需要在\[0,1\]区间内，至少2维                                                                            |
| `copula_type` | string | 字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维                        |
| `method`      | string | 字符串，极大似然估计方法(多元分布时有效)；ML —最大似然估计 （默认）；AML —调整的似然估计，性能上比MLE快，但不适用于中小样本量 |
| `options`     | array  | 数组，估计规划条件，可为空                                                                                                    |

返回：array

## `randCopula(copula_type, rho, v, n)`

生成服从copula分布的随机数

| 参数          | 类型    | 说明                                                                              |
| ------------- | ------- | --------------------------------------------------------------------------------- |
| `copula_type` | string  | 字符串，分布函数类型:gaussian、t、clayton、frank、gumbel                          |
| `rho`         | array   | 数组，协方差矩阵，对阿基米德族(clayton、frank、gumbel分布)为空                    |
| `v`           | float   | 实数，对t分布为自由度；对阿基米德族(clayton、frank、gumbel分布)为参数估计值，且其 |
| `n`           | integer | 整数，产生随机数长度                                                              |

返回：array

### 示例

范例01：gaussian分布

```tsl
rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
n := 10;
v := array((0, 0, 0), (0, 0, 0), (0, 0, 0));
return randCopula("gaussian", rho, v, n);
```

范例02：t分布

```tsl
rho := array(
(1.0000, 0.9239, 0.0358),
(0.9239, 1.0000, 0.0843),
(0.0358, 0.0843, 1.0000)
);
n := 10;
return randCopula("t", rho, 3, n);
```

范例03：阿基米德族，clayton(frank、gumbel调用相同)

```tsl
alpha := 1;
n := 10;
return randCopula("clayton", nil, alpha, n);
```

## `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_Ridge(y, x, k, constant, alpha)`

岭回归，程序中对x进行了标准化，再结合岭回归系数去计算回归方程的系数，程序返回的结果，每一行为一组回归系数。 Regress_Ridge(y,x) 输出x对y的岭回归，k的选取依据方差扩大因子法 Regress_Ridge(y,x,k) k是一个实数，输出x对y的岭回归，k是一个长度大于1的数组，输出x对y的岭迹

| 参数       | 类型  | 说明                                                                         |
| ---------- | ----- | ---------------------------------------------------------------------------- |
| `y`        | array | 被解释变量序列，为一维数组类型                                               |
| `x`        | array | 解释变量矩阵，为二维数组类型，每一列为一个解释变量                           |
| `k`        | array | 岭回归系数，0到1之间的实数，可为整数或一维数组类型；缺省使用方差扩大因子选取 |
| `constant` | bool  | 是否包含常数项，为布尔类型，缺省为1                                          |
| `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_WLS(y, x, w, u)`

加权最小二乘法

| 参数 | 类型  | 说明                                             |
| ---- | ----- | ------------------------------------------------ |
| `y`  | array | 因变量序列，为一维数组类型；                     |
| `x`  | array | 自变量矩阵，为二维数组类型，每一列为一个自变量； |
| `w`  | array | 权重序列，为一维数组类型；                       |
| `u`  | array | 残差序列，为一维数组类型；                       |

返回：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

## `Regress_VIFR2(x, w, constant)`

vif分析增强

| 参数       | 类型 | 说明          |
| ---------- | ---- | ------------- |
| `x`        | any  | 表达式,自变量 |
| `w`        | any  | 表达式,权重   |
| `constant` | bool | object        |

返回：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
```
