2162 lines
79 KiB
Markdown
2162 lines
79 KiB
Markdown
# 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
|