# Builtin - 数学 / 统计与分布

## `randG(mean, std_dev)`

声明：function

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

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

返回：real

### 示例

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

## `gamma(x)`

声明：function

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

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

返回：array

### 示例

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

## `gammaln(x)`

声明：function

计算对数gamma

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

返回：array

### 示例

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

## `erf(x)`

声明：function

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

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

返回：array

### 示例

```tsl
return erf(0.15);
// 输出：0.168
```

## `erfinv(x)`

声明：function

误差函数逆函数

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

返回：array

### 示例

```tsl
return erfinv(0.15);
// 输出：0.13372692166482
```

## `erfc(x)`

声明：function

误差累计分布函数

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

返回：array

### 示例

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

## `erfcinv(x)`

声明：function

误差累计逆函数

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

返回：array

### 示例

```tsl
return erfcinv(0.15);
// 输出：1.01790246483203
```

## `minIntValue(data)`

声明：function

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

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

声明：function

计算一组实数的平方和

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

声明：function

计算一组实数的总和以及平方和，执行完毕后，总和存在参数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)`

声明：function

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

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

声明：function

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

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

声明：function

估计一组数据的平均值和标准差。执行完毕后，平均值放在参数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)`

声明：function

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

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

返回：real

### 示例

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

## `totalVariance(data)`

声明：function

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

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

声明：function

计算一组数据的中位数

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

返回：real

### 示例

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

## `mode(data)`

声明：function

计算一组数据的众数

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

声明：function

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

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

声明：function

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

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

返回：real

### 示例

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

## `cov(data1, data2)`

声明：function

两个数据间的协方差

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

声明：function

两个数据间的相关系数

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

声明：function

两个数据间的回归斜率

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

声明：function

两个数据间的回归截距

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

声明：function

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

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

声明：function

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

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

声明：function

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

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

声明：function

数据集中四分位的值

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

声明：function

返回一组实数中的最小值

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

声明：function

返回一组实数中的最大值

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

声明：function

计算一组数的算术平均值

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

声明：function

计算一组数的总和

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

声明：function

计算一组数据的平方和的平方根，也就是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)`

声明：function

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

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

声明：function

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

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

声明：function

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

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

声明：function

计算一组数据的偏度，算法和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)`

声明：function

计算一组数据的偏度，算法和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)`

声明：function

计算一组数据的峰度，算法和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)`

声明：function

计算一组数据的峰度，算法和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)`

声明：function

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

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

声明：function

返回累乘值

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

声明：function

找出第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)`

声明：function

找出第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)`

声明：function

数据集中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)`

声明：function

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

声明：function

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

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

声明：function

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

声明：function

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

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

声明：function

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

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

声明：function

计算序列百分点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'));
```

## `std(rsp_cycle, n)`

声明：function

已实现波动率(%)

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

返回：float

## `stdUp(rsp_cycle, n)`

声明：function

高频上行波动率(%)

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

返回：float

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

声明：function

S=|R|/(V^beta)

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

返回：float

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

声明：function

S=|R|/ln(V)

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

返回：float

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

声明：function

净委买变化率偏度

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

返回：float

## `sf_exppdf(values, lambda_value)`

声明：function

计算指数分布概率密度。

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

返回：array

## `sf_expcdf(values, lambda_value)`

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

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

声明：function

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

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

返回：array

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

声明：function

执行双因素方差分析。

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

返回：array

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

声明：function

执行符号检验。

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

返回：array

## `correlpaired(a, b)`

声明：function

功能：计算 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)`

声明：function

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

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

返回：array

## `sf_SinX(x, v)`

声明：function

正弦积分的定义为

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

返回：any

## `sf_CosX(x, v)`

声明：function

余弦积分的定义为

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

返回：any

## `sf_eX(x, v)`

声明：function

指数积分的定义为

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

返回：any

## `sf_Gamma(x, v)`

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

## `sf_Error(x, v)`

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

## `sf_normalinv2(data, v)`

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

## `sf_gammainv(probability, alpha, v)`

声明：function

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

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

返回：any

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

声明：function

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

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

返回：any

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

声明：function

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

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

返回：array

### 示例

范例01：

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

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

声明：function

估计多元函数分布值

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

返回：array

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

声明：function

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

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

返回：array

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

声明：function

生成服从copula分布的随机数

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

返回：array

### 示例

范例01：gaussian分布

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

范例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);
```

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

声明：function

vif分析增强

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

返回：array