csh
1f19954dd7
Move runtime and document pages into their correct scope, remove obsolete pending entries, and regenerate the function index.\nUpdate agent test guidance and API skill routing to match the new reference layout.
77 KiB
77 KiB
Builtin - 数学 / 统计与分布
randG(mean, std_dev)
随机产生均值为Mean，标准差为StdDev的服从高斯分布的数据。往往用于模拟取样误差。
| 参数 | 类型 | 说明 |
|---|---|---|
mean |
real | 作为产生正态分布的均值 |
std_dev |
real | 作为产生正态分布的标准差，大于0 |
返回：real
示例
return randG (2, 3);
// 输出：3.05 //3.05是均值为2,标准差为3的高斯分布的一个样本数据
gamma(x)
计算伽马(Gamma)函数的数值
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 大于0,支持数值数组。 |
返回：array
示例
return gamma(array(1.5, 2.3, 3.4));
// 输出：array(0.886226925452758,1.16671190519816,2.98120642681033)
gammaln(x)
计算对数gamma
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 大于0,支持数值数组。 |
返回：array
示例
return gammaln(array(1.5, 2.3, 3.4));
// 输出：array(-0.120782237635245,0.15418945495963,1.09232805980274)
erf(x)
误差函数也称为概率函数，其定义为
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 实型变量。支持数组 |
返回：array
示例
return erf(0.15);
// 输出：0.168
erfinv(x)
误差函数逆函数
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 实型变量,支持数组 |
返回：array
示例
return erfinv(0.15);
// 输出：0.13372692166482
erfc(x)
误差累计分布函数
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 实型变量。支持数组 |
返回：array
示例
return erfc(0.15);
// 0.832004028572637
erfcinv(x)
误差累计逆函数
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 实型变量.支持数组 |
返回：array
示例
return erfcinv(0.15);
// 输出：1.01790246483203
minIntValue(data)
返回一组实数数据中的最小值的整数部分
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放整数的数组，如果输入是实数，计算先取整数部分 |
返回：integer
示例
a := array(5.3, 3.9, 5.6, 5, 6.5, 7.6);
return minIntValue (a);
// 输出：3
sumOfSquares(data)
计算一组实数的平方和
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
a := array(2, 3, 1, 5, 6.5, 7.5);
return sumOfSquares (a);
// 输出：124
sumsAndSquares(data, sum, sum_of_squares)
计算一组实数的总和以及平方和，执行完毕后，总和存在参数Sum，平方和存在参数SumOfSquares中
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
sum |
real | 实数，用来存放总和 |
sum_of_squares |
real | 实数，用来存放平方和 |
返回：any
示例
a := array(2, 3, 1, 5, 6, 7);
// b是总和,c是平方和
sumsAndSquares (a, b, c);
return array(b, c);
// 输出：
// array(24.0,124.0)
maxIntValue(data)
返回一组实数中的最大值的整数部分
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放整数的数组名，如果输入是实数，计算先取整数部分 |
返回：integer
示例
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return maxIntValue (a);
// 输出：7
sumInt(data)
计算一组数整数部分的总和
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放整数的数组 |
返回：integer
示例
a := array(2, 3, 1, 5, 6.5, 7.5);
return sumInt(a);
// 输出：24
meanAndStdDev(data, mean, std_dev)
估计一组数据的平均值和标准差。执行完毕后，平均值放在参数Mean中，标准差放在参数StdDev中
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 实数数组 |
mean |
real | 实数，存放平均值 |
std_dev |
real | 实数，存放标准差 |
返回：any
示例
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
// b是返回的平均值,c是返回的标准差
meanAndStdDev (a, b, c);
return array(b, c);
// 输出：
// array(5.81666666666667,1.46070759108956)
aveDev(data)
计算一组数据与均值绝对偏差的平均值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
data := array(5, 3, 6, 8, 9, 10, 4);
// 返回数组Data的平均绝对偏
return aveDev (data);
// 输出：2.2
totalVariance(data)
计算一组数据对其算术平均数的离差平方和（总体偏差）
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return totalVariance (a);
// 输出：10.6683333333333
median(data)
计算一组数据的中位数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
data := array(5, 3, 6, 8, 9, 10, 4);
return median (data);
// 输出：6
mode(data)
计算一组数据的众数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
data := array(5, 3, 6, 8, 9, 10, 4);
return mode(data);
// 输出：3
momentSkewKurtosis(data, m1, m2, m3, m4, skew, kurtosis)
计算一组数据的各项统计指标
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
m1 |
real | 数据平均值 |
m2 |
real | 数据的方差 |
m3 |
real | 数据的三阶中心距 |
m4 |
real | 数据的四阶中心距 |
skew |
real | 偏度，反映数据不对称的程度 |
kurtosis |
real | 峰度，反映数据集中的程度 |
返回：any
示例
data := array(5, 3, 6, 8, 9, 10, 4);
momentSkewKurtosis(data, m1, m2, m3, m4, skew, kurtosis);
return array(m1, m2, m3, m4, skew, kurtosis);
// 输出：
// array(6.42857142857143,5.95918367346938,1.25947521865896,55.6684714702205,0.0865783828574166,1.56760180146369)
devSq(data)
计算一组数据样本平均值偏差的平方和
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
data := array(5, 3, 6, 8, 9, 10, 4);
return devSq(data);
// 输出：41.71
cov(data1, data2)
两个数据间的协方差
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘的协方差
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return cov(data[: , "价格"], data[: , "大盘"]);
correl(data1, data2)
两个数据间的相关系数
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘价格的相关系数
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return correl(data[: , "价格"], data[: , "大盘"]);
slope(data1, data2)
两个数据间的回归斜率
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return slope(data[: , "价格"], data[: , "大盘"]);
intercept(data1, data2)
两个数据间的回归截距
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价的相回归截距
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return intercept(data[: , "价格"], data[: , "大盘"]);
rsq(data1, data2)
两个数据间的乘积矩相关系数平方
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘的乘积矩相关系数平方
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return rsq(data[: , "价格"], data[: , "大盘"]);
steyx(data1, data2)
两个数据间的相对标准偏差
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘的相对标准偏差
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return steyx(data[: , "价格"], data[: , "大盘"]);
slopeandintercept(data1, data2)
两个数据间的回归斜率和截距
| 参数 | 类型 | 说明 |
|---|---|---|
data1 |
array | 数据，一维数组 |
data2 |
array | 数据，一维数组 |
返回：real
示例
// 万科A在2018/10/1~2018/10/30日线收盘与大盘收盘价格的回归斜率和截距
begt := 20181001T;
endt := 20181030T;
setSysParam(Pn_Stock(), "SZ000002");
date_arr := marketTradeDayQk(begt, endt);
data := select thisrow as "日期",
spec(specDate(close(), thisrow), "SZ000002") as "价格",
spec(specDate(close(), thisrow), "SH000001") as "大盘"
from dateArr
end;
return slopeandintercept(data[: , "价格"], data[: , "大盘"]);
quartile(data, x)
数据集中四分位的值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
x |
integer | 整数，0-4表示第几个四分点，为0的结果是数据集中最小的数，为4的结果是数据集中最大的数 |
返回：real
示例
// 返回数组Data中第3个四分位数,即75%。然后按照Percentile的算法求值
// (7-1)*75%=4.5，i=4，j=5，最终结果是(1-0.5)*8+0.5*9=8.5
data := array(5, 3, 6, 8, 9, 10, 4);
return quartile(data, 3);
// 输出：8.5
minValue(data, rc, ml, assign, abnormal, fill)
返回一组实数中的最小值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列最小值；1求行最小值；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其最小值；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求最小值
a := array(2, 3, 1, 5, 6, 7);
return minValue (a);
// 输出：1
范例02：二维数组指定列+指定步长计算最小值
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-最小"] := minValue(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.150146444095299,"B":0.0720029249787331,"A-最小":0.150146444095299),
// ("A":0.752386756474152,"B":0.794236877467483,"A-最小":0.150146444095299),
// ("A":0.875261440640315,"B":0.24984975066036,"A-最小":0.150146444095299),
// ("A":0.273097287165001,"B":0.905757479835302,"A-最小":0.150146444095299),
// ("A":0.725633884547278,"B":0.73020756803453,"A-最小":0.150146444095299),
// ("A":0.640606550732628,"B":0.688115618657321,"A-最小":0.150146444095299),
// ("A":0.942538371076807,"B":0.245572400279343,"A-最小":0.150146444095299),
// ("A":0.898009897442535,"B":0.00986421713605523,"A-最小":0.150146444095299),
// ("A":0.884120375616476,"B":0.413575921207666,"A-最小":0.150146444095299),
// ("A":0.0179871807340533,"B":0.90700996434316,"A-最小":0.0179871807340533))
maxvalue(data, rc, ml, assign, abnormal, fill)
返回一组实数中的最大值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列最大值；1求行最大值；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其最大值；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求最大值
a := array(5.3, 3.9, 5.6, 5, 6.5, 7.6);
return maxValue (a);
// 输出：7.6
范例02：二维数组指定列+指定步长计算最大值
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-最大"] := maxValue(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.958783811656758,"B":0.707278462126851,"A-最大":0.958783811656758),
// ("A":0.750536063918844,"B":0.200482148211449,"A-最大":0.958783811656758),
// ("A":0.517184586962685,"B":0.178965070284903,"A-最大":0.958783811656758),
// ("A":0.846249950351194,"B":0.059791746083647,"A-最大":0.958783811656758),
// ("A":0.189113092375919,"B":0.773908615112305,"A-最大":0.958783811656758),
// ("A":0.789464950794354,"B":0.578314067330211,"A-最大":0.958783811656758),
// ("A":0.59376598126255,"B":0.8564029103145,"A-最大":0.958783811656758),
// ("A":0.493202868150547,"B":0.528921798337251,"A-最大":0.958783811656758),
// ("A":0.384325044928119,"B":0.3864487092942,"A-最大":0.958783811656758),
// ("A":0.977926453808323,"B":0.866223617922515,"A-最大":0.977926453808323))
mean(data, rc, ml, assign, abnormal, fill)
计算一组数的算术平均值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列平均；1求行平均；默认为0 |
ml |
integer | 可选参数，移动步长，求移动平均步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其均值；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求平均值
a := array(2, 3, 1, 5, 6, 7);
return mean(a);
// 输出：4
范例02：二维数组指定列+指定步长计算平均
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-平均"] := mean(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.87071518227458,"B":0.582499709213153,"A-平均":0.87071518227458),
// ("A":0.881466222461313,"B":0.764262322103605,"A-平均":0.876090702367947),
// ("A":0.806781190447509,"B":0.855670898454264,"A-平均":0.852987531727801),
// ("A":0.999613848049194,"B":0.0568885344546288,"A-平均":0.889644110808149),
// ("A":0.481501111760736,"B":0.797956990310922,"A-平均":0.808015510998666),
// ("A":0.108187671285123,"B":0.354029157897458,"A-平均":0.691377537713076),
// ("A":0.581335202790797,"B":0.581649502040818,"A-平均":0.67565720415275),
// ("A":0.518596450332552,"B":0.212483842624351,"A-平均":0.656024609925225),
// ("A":0.639061011373997,"B":0.364532657200471,"A-平均":0.654139765641756),
// ("A":0.239243724849075,"B":0.521682396298274,"A-平均":0.612650161562488))
sum(data, rc, ml, assign, abnormal, fill)
计算一组数的总和
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列的和；1求行的和；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其合计值；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求和
a := array(2, 3, 1, 5, 6, 7);
return sum(a);
// 输出：24
范例02：二维数组指定列+指定步长求和
arr := ones(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-累加"] := sum(arr, 0, ml, "A");
return arr;
// 输出：
// 示例包含说明文字，未作为可执行片段运行。
norm(data, rc, ml, assign, abnormal, fill)
计算一组数据的平方和的平方根，也就是Sqrt(SumOfSquares)
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列平方和的平方根；1求行平方和的平方根；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其平方和的平方根；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real
示例
范例01：一维数组求平方和的平方根
a := array(5, 3, 5, 5, 7, 7);
return norm(a);
// 输出：13.490737563232
范例02：二维数组指定列+指定步长计算平方和的平方根
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-平方和的平方根"] := norm(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.183076372835785,"B":0.990034059388563,"A-平方和的平方根":0.183076372835785),
// ("A":0.251783866435289,"B":0.299099538708106,"A-平方和的平方根":0.311307040858075),
// ("A":0.49730991339311,"B":0.890515994047746,"A-平方和的平方根":0.586710510939487),
// ("A":0.0872881365939975,"B":0.574711061315611,"A-平方和的平方根":0.593168140106097),
// ("A":0.528904323000461,"B":0.131601712433621,"A-平方和的平方根":0.79472525147091),
// ("A":0.785433517768979,"B":0.914764100918546,"A-平方和的平方根":1.11736029827467),
// ("A":0.404511127155274,"B":0.0298984514083713,"A-平方和的平方根":1.18832793796699),
// ("A":0.0960042411461473,"B":0.651920047821477,"A-平方和的平方根":1.19219969068564),
// ("A":0.456138449255377,"B":0.338952687336132,"A-平方和的平方根":1.27648046885177),
// ("A":0.00426198542118073,"B":0.550133779877797,"A-平方和的平方根":1.27648758391132))
stdDev(data, rc, ml, assign, abnormal, fill)
计算一组数据的标准差的估计（样本标准差），数学公式如下：
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列样本标准差；1求行样本标准差；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其样本标准差；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求样本标准差
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return stdDev (a);
// 输出：1.46070759108956 //样本a的标准差
范例02：二维数组指定列+指定步长计算样本标准差
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-样本标准差"] := stdDev(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.15182253299281,"B":0.315825292607769,"A-样本标准差":0.0),
// ("A":0.577175007201731,"B":0.838894178392366,"A-样本标准差":0.300769618907604),
// ("A":0.913798103574663,"B":0.327133466256782,"A-样本标准差":0.381847833237904),
// ("A":0.874265916645527,"B":0.694091119104996,"A-样本标准差":0.351970269974613),
// ("A":0.873455712106079,"B":0.718590721255168,"A-样本标准差":0.323787099621693),
// ("A":0.671421690843999,"B":0.249334673630074,"A-样本标准差":0.28961683255538),
// ("A":0.34758283989504,"B":0.831702823517844,"A-样本标准差":0.292231994406431),
// ("A":0.214012956246734,"B":0.170686958590522,"A-样本标准差":0.307933683143253),
// ("A":0.61253499193117,"B":0.52847190736793,"A-样本标准差":0.288276298285835),
// ("A":0.96317343134433,"B":0.269431800814346,"A-样本标准差":0.297346945279902))
popnStdDev(data, rc, ml, assign, abnormal, fill)
计算一组数据的总体标准差，数学公式：
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列总体标准差；1求行总体标准差；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其总体标准差；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求总体标准差
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return popnStdDev (a);
// 输出：1.33343749593131
范例02：二维数组指定列+指定步长计算总体标准差
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-总体标准差"] := popnStdDev(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.0316496836021543,"B":0.838673108490184,"A-总体标准差":0.0),
// ("A":0.0380017445422709,"B":0.016102873487398,"A-总体标准差":0.00317603047005831),
// ("A":0.865900214761496,"B":0.421355169499293,"A-总体标准差":0.391780859156006),
// ("A":0.531020013149828,"B":0.991538721835241,"A-总体标准差":0.352314903801803),
// ("A":0.356325420551002,"B":0.24732820619829,"A-总体标准差":0.315147053389551),
// ("A":0.068206172902137,"B":0.404504089383409,"A-总体标准差":0.308162811041045),
// ("A":0.508473539724946,"B":0.705417396733537,"A-总体标准差":0.293211170252909),
// ("A":0.14910603640601,"B":0.279827648540959,"A-总体标准差":0.281654950955512),
// ("A":0.831985981203616,"B":0.0213200200814754,"A-总体标准差":0.310721312537621),
// ("A":0.0396571704186499,"B":0.384453092468903,"A-总体标准差":0.311531618685409))
variance(data, rc, ml, assign, abnormal, fill)
计算一组数据的方差的估计（样本方差），数学公式：
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列样本方差；1求行样本方差；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其样本方差；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求样本方差
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return variance (a);
// 输出：2.13366666666666
范例02：二维数组指定列+指定步长计算样本方差
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-样本方差"] := variance(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.0976159237325191,"B":0.482796263182536,"A-样本方差":0.0),
// ("A":0.883788225706667,"B":0.639443505322561,"A-样本方差":0.309033444195665),
// ("A":0.297417941503227,"B":0.866883828537539,"A-样本方差":0.166969640815567),
// ("A":0.767699372489005,"B":0.0667955267708749,"A-样本方差":0.140455909946851),
// ("A":0.425307923927903,"B":0.222725304076448,"A-样本方差":0.106832245256288),
// ("A":0.932575504761189,"B":0.838074648519978,"A-样本方差":0.117470409113205),
// ("A":0.108969272114337,"B":0.241227929713205,"A-样本方差":0.127914790428133),
// ("A":0.345403993967921,"B":0.100473587168381,"A-样本方差":0.11270303845495),
// ("A":0.39564486593008,"B":0.465002589160577,"A-样本方差":0.0994504149628084),
// ("A":0.00122168054804206,"B":0.989088654285297,"A-样本方差":0.110630838406093))
skewness(data, rc, ml, assign, abnormal, fill)
计算一组数据的偏度，算法和excel兼容
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列偏度；1求行偏度；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其偏度；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求偏度
data := array(5, 3, 6, 8, 9, 10, 4);
return skewness (data);
// 输出：0.11
范例02：二维数组指定列+指定步长计算偏度
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-偏度"] := skewness(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.345008506439626,"B":0.947316359030083,"A-偏度":NAN),
// ("A":0.456479304004461,"B":0.314875329611823,"A-偏度":NAN),
// ("A":0.542076414451003,"B":0.465758888283745,"A-偏度":-0.389761200780375),
// ("A":0.830417833756656,"B":0.674252083292231,"A-偏度":1.12823697245901),
// ("A":0.692654144950211,"B":0.513484538765624,"A-偏度":0.305098325022161),
// ("A":0.175067013595253,"B":0.0867823071312159,"A-偏度":-0.0145265618339346),
// ("A":0.997625324875116,"B":0.229432929540053,"A-偏度":0.131336671537343),
// ("A":0.607732360716909,"B":0.00203069648705423,"A-偏度":0.0768566639543401),
// ("A":0.769998977892101,"B":0.25457691331394,"A-偏度":-0.181274403805795),
// ("A":0.462916810531169,"B":0.490705287782475,"A-偏度":0.0103060619790022))
skewness2(data, rc, ml, assign, abnormal, fill)
计算一组数据的偏度，算法和matlab兼容
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列偏度；1求行偏度；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其偏度；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组求偏度
data := array(5, 3, 6, 8, 9, 10, 4);
return skewness2(data);
// 输出：0.09
范例02：二维数组指定列+指定步长计算偏度
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-偏度"] := skewness2(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.6100484195631,"B":0.715981872752309,"A-偏度":NAN),
// ("A":0.993454972514883,"B":0.599585968535394,"A-偏度":0.0),
// ("A":0.372750075301156,"B":0.444524445571005,"A-偏度":0.278760317564702),
// ("A":0.550206494750455,"B":0.647872807923704,"A-偏度":0.635048178529647),
// ("A":0.408510100794956,"B":0.953352153301239,"A-偏度":0.952205303351184),
// ("A":0.536475122207776,"B":0.74982732674107,"A-偏度":1.15164267581698),
// ("A":0.571144290035591,"B":0.0298545127734542,"A-偏度":1.26050077048314),
// ("A":0.230761173414067,"B":0.755714789498597,"A-偏度":0.85583534867919),
// ("A":0.150797324953601,"B":0.0688467305153608,"A-偏度":0.619687690263225),
// ("A":0.077599665382877,"B":0.990505203139037,"A-偏度":0.486284607637024))
kurtosis(data, rc, ml, assign, abnormal, fill)
计算一组数据的峰度，算法和excel兼容
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列峰度；1求行峰度；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其峰度；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组计算峰度
data := array(5, 3, 6, 8, 9, 10, 4);
return kurtosis(data);
// 输出：-1.64
// 输出：-1.64
范例02：二维数组指定列+指定步长计算峰度
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-峰度"] := kurtosis(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.980047498596832,"B":0.402004413306713,"A-峰度":NAN),
// ("A":0.633000277215615,"B":0.990959876682609,"A-峰度":NAN),
// ("A":0.0302784142550081,"B":0.897569506429136,"A-峰度":NAN),
// ("A":0.952995504485443,"B":0.902370758820325,"A-峰度":1.14914121941789),
// ("A":0.647436241386458,"B":0.798524161800742,"A-峰度":1.75277777253052),
// ("A":0.106838567415252,"B":0.783145941328257,"A-峰度":-1.79403146968547),
// ("A":0.940166180720553,"B":0.361717429943383,"A-峰度":-1.27336988351427),
// ("A":0.696889952989295,"B":0.985664031002671,"A-峰度":-0.658650953176948),
// ("A":0.123242125613615,"B":0.675423074513674,"A-峰度":-1.65506451391199),
// ("A":0.986539963865653,"B":0.68698396300897,"A-峰度":-1.41423021480228))
kurtosis2(data, rc, ml, assign, abnormal, fill)
计算一组数据的峰度，算法和matlab兼容
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列峰度；1求行峰度；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其峰度；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real
示例
范例01：：一维数组计算峰度
data := array(5, 3, 6, 8, 9, 10, 4);
return kurtosis2(data);
// 输出：1.57
范例02：二维数组指定列+指定步长计算峰度
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-峰度"] := kurtosis2(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.655130569823086,"B":0.169059717329219,"A-峰度":NAN),
// ("A":0.848595677409321,"B":0.331126981182024,"A-峰度":1.00000000000272),
// ("A":0.0950429700314999,"B":0.555930029833689,"A-峰度":1.5),
// ("A":0.741949734743685,"B":0.7052144294139,"A-峰度":2.19701539579311),
// ("A":0.0635894564911723,"B":0.696825876133516,"A-峰度":1.23130776662201),
// ("A":0.975331973750144,"B":0.707070349482819,"A-峰度":1.52458726295925),
// ("A":0.199741119518876,"B":0.772686692187563,"A-峰度":1.30375485345706),
// ("A":0.133859496098012,"B":0.414379859110341,"A-峰度":1.27199062552285),
// ("A":0.402421594597399,"B":0.580620889784768,"A-峰度":1.43616776036497),
// ("A":0.465525532606989,"B":0.129364971769974,"A-峰度":1.59328967992336))
harmean(data, rc, ml, assign, abnormal, fill)
计算一组数据的调和平均数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列调和平均数；1求行调和平均数；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其调和平均数；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
范例01：一维数组计算调和平均数
data := array(5, 3, 6, 8, 9, 10, 4);
return harmean(data);
// 输出：5.44
范例02：二维数组指定列+指定步长计算调和平均数
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-调和平均数"] := harmean(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.124961190624163,"B":0.0598194859921932,"A-调和平均数":0.124961190624163),
// ("A":0.857839953387156,"B":0.141636071261019,"A-调和平均数":0.218145252665682),
// ("A":0.65432970575057,"B":0.0625838069245219,"A-调和平均数":0.280465973816327),
// ("A":0.458887472050265,"B":0.121089172083885,"A-调和平均数":0.310663488719166),
// ("A":0.613102434901521,"B":0.116132015362382,"A-调和平均数":0.344667921602947),
// ("A":0.785793515155092,"B":0.855155329685658,"A-调和平均数":0.380244620081035),
// ("A":0.799667620798573,"B":0.722903371788561,"A-调和平均数":0.411043312484736),
// ("A":0.653244619490579,"B":0.679718399886042,"A-调和平均数":0.431019257240658),
// ("A":0.955700401915237,"B":0.652552865445614,"A-调和平均数":0.459019535579044),
// ("A":0.965912215644494,"B":0.150117957498878,"A-调和平均数":0.484442154536813))
product(data, rc, ml, assign, abnormal, fill)
返回累乘值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
rc |
integer | 可选参数，行列选择:0求列累乘值；1求行累乘值；默认为0 |
ml |
integer | 可选参数，移动步长，默认不移动 |
assign |
integer | 可选参数，对字段筛选,指定某些行列，求其累乘值；默认全部 |
abnormal |
integer | 可选参数，异常处理参数，按照存储位来进行管理: |
fill |
any | 可选参数，data 为空时的返回 |
返回：real or array
示例
// 一维数组计算累乘值
data := array(5, 3, 6, 8, 9, 10, 4);
return product (data);
// 输出：259200 //返回5*3*6*8*9*10*4
范例02：二维数组指定列+指定步长计算累乘值
arr := rand(10, array("A", "B")) * 10;
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-累乘"] := product(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":3.50745165487751,"B":8.34431231953204,"A-累乘":3.50745165487751),
// ("A":6.7908460390754,"B":5.874217399396,"A-累乘":23.8185641777734),
// ("A":5.74234192026779,"B":0.828072652220726,"A-累乘":136.774339558617),
// ("A":4.92611460620537,"B":0.982504128478467,"A-累乘":673.766071853797),
// ("A":2.6915419078432,"B":8.85313867591322,"A-累乘":1813.46961847739),
// ("A":2.64794702874497,"B":3.58003713656217,"A-累乘":4801.97148796647),
// ("A":5.65035830019042,"B":3.64946177229285,"A-累乘":27132.8594543091),
// ("A":7.37319005886093,"B":4.58649940323085,"A-累乘":200055.729596983),
// ("A":5.89445208897814,"B":2.48157736845315,"A-累乘":1179218.91323498),
// ("A":7.35567317577079,"B":2.42680004332215,"A-累乘":8673948.92844412))
large(data, n, rc, ml, assign, abnormal, fill)
找出第N最大的数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
n |
integer | 表示序号，1表示最大的数据 |
rc |
integer | 行列选择:0求列第N最大的数；1求行第N最大的数；默认为0 |
ml |
integer | 移动步长，默认不移动 |
assign |
integer | 对字段筛选,指定某些行列，求其第N最大的数；默认全部 |
abnormal |
integer | 异常处理参数，按照存储位来进行管理: |
fill |
any | data 为空时的返回 |
返回：real
示例
data := array(5, 3, 6, 8, 9, 10, 4);
// 返回数组Data中第3大的数据
return large (data, 3);
// 输出：8
small(data, n, rc, ml, assign, abnormal, fill)
找出第N最小的数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
n |
integer | 表示序号，1表示最小的数据 |
rc |
integer | 行列选择:0求列第N最小的数；1求行第N最小的数；默认为0 |
ml |
integer | 移动步长，默认不移动 |
assign |
integer | 对字段筛选,指定某些行列，求其第N最小的数；默认全部 |
abnormal |
integer | 异常处理参数，按照存储位来进行管理: |
fill |
any | data 为空时的返回 |
返回：real
示例
// 返回数组Data中第3小的数据
data := array(5, 3, 6, 8, 9, 10, 4);
return small (data, 3);
// 输出：5
percentrank(data, x, rc, ml, assign, abnormal, fill)
数据集中X在该组数据中的百分点
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
x |
real | 实数，在数据集外的数的百分位使用线性插值得到 |
rc |
integer | 行列选择:0求列百分点；1求行百分点；默认为0 |
ml |
integer | 移动步长，默认不移动 |
assign |
integer | 对字段筛选,指定某些行列，求其百分点；默认全部 |
abnormal |
integer | 异常处理参数，按照存储位来进行管理: |
fill |
any | data 为空时的返回 |
返回：real
示例
// 返回8在数组Data的百分点，即小于8的个数/（小于8个数+大于8个
// 数）结果是4/6
data := array(5, 3, 6, 8, 9, 10, 4);
return percentrank(data, 8);
// 输出：0.666666666666667
rank(data, x, rc, ml, assign, abnormal, fill)
返回X在DATA中的排名(Data从大到小排列)，该数据必需存在在Data中。
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
x |
real | 实数 |
rc |
integer | 行列选择:0求列排名；1求行排名；默认为0 |
ml |
integer | 移动步长，默认不移动 |
assign |
integer | 对字段筛选,指定某些行列，求其排名；默认全部 |
abnormal |
integer | 异常处理参数，按照存储位来进行管理: |
fill |
any | data 为空时的返回 |
返回：real
示例
data := array(5, 3, 6, 8, 9, 10, 4);
return rank(data, 8);
// 输出：3
trimmean(data, x, rc, ml, assign, abnormal, fill)
返回去掉头尾百分数以后的平均值。算法如下：
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
x |
real | 百分比，实数，一般在0-1之间 |
rc |
integer | 行列选择:0求列排名；1求行排名；默认为0 |
ml |
integer | 移动步长，默认不移动 |
assign |
integer | 对字段筛选,指定某些行列，求其排名；默认全部 |
abnormal |
integer | 异常处理参数，按照存储位来进行管理: |
fill |
any | data 为空时的返回 |
返回：real
示例
// 去除个数=总个数7*0.7=4.9，头和尾各去除2个数据，剩下数据5，6，8求//均值
data := array(5, 3, 6, 8, 9, 10, 4);
return trimmean(data, 0.7);
// 输出：6.33333333333333
frequency(data, freq_data, rc, ml, assign, abnormal, fill)
返回DATA在FreqData分割区间中的出现个数。
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
freq_data |
array of real | 分割区间，如果为array(1,2,3)则表示需要计算Data 分别落在(-inf,1),(1,2),(2,3),(3,inf)四个区间的个数(频数) |
rc |
integer | 行列选择:0求列排名；1求行排名；默认为0 |
ml |
integer | 移动步长，默认不移动 |
assign |
integer | 对字段筛选,指定某些行列，求其排名；默认全部 |
abnormal |
integer | 异常处理参数，按照存储位来进行管理: |
fill |
any | data 为空时的返回 |
返回：array of integer
示例
data := array(5, 3, 6, 8, 9, 10, 4);
freq_data := array(1, 2, 3);
return frequency(data, freq_data);
// 输出：
// array(0,0,1,6)
geomean(data)
计算一组数据的几何平均数
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
范例01：一维数组计算几何平均数
data := array(5, 3, 6, 8, 9, 10, 4);
return geomean (data);
// 输出：5.93
范例02：二维数组指定列+指定步长计算几何平均数
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-几何平均数"] := geomean(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.519830256002024,"B":0.374670889694244,"A-几何平均数":0.519830256002024),
// ("A":0.765975012211129,"B":0.00843984819948673,"A-几何平均数":0.631012667613626),
// ("A":0.402682410785928,"B":0.294473465066403,"A-几何平均数":0.543266516297067),
// ("A":0.66125158383511,"B":0.80891461763531,"A-几何平均数":0.570625775662063),
// ("A":0.239383002044633,"B":0.718946079257876,"A-几何平均数":0.479622744628361),
// ("A":0.335142631782219,"B":0.669408179819584,"A-几何平均数":0.451808871517444),
// ("A":0.664034612709656,"B":0.788084068801254,"A-几何平均数":0.477359539816948),
// ("A":0.0850369480904192,"B":0.813925041817129,"A-几何平均数":0.384760839429897),
// ("A":0.231962512480095,"B":0.205027454067022,"A-几何平均数":0.363723728819524),
// ("A":0.809202993987128,"B":0.396649306640029,"A-几何平均数":0.394003626650774))
popnVariance(data)
计算一组数据的总体方差，数学公式：
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 存放实数的数组 |
返回：real
示例
范例01：一维数组求总体方差
a := array(5.3, 3.9, 5.6, 5, 7.5, 7.6);
return popnVariance(a);
// 输出：1.77805555555555
范例02：二维数组指定列+指定步长计算总体方差
arr := rand(10, array("A", "B"));
ml := length(arr); // 移动步长--指定大于等于总长度数，则统计从首行到当前行的区间
arr[: , "A-总体方差"] := popnVariance(arr, 0, ml, "A");
return arr;
// 输出：
// array(
// ("A":0.564295332413167,"B":0.198089802404866,"A-总体方差":0.0),
// ("A":0.166125119663775,"B":0.0624075580853969,"A-总体方差":0.039634879580224),
// ("A":0.378304088953883,"B":0.14998382772319,"A-总体方差":0.0264613528859377),
// ("A":0.318244896829128,"B":0.703246884280816,"A-总体方差":0.0203400328742531),
// ("A":0.568663859274238,"B":0.957403063541278,"A-总体方差":0.0234577418324268),
// ("A":0.257466434501112,"B":0.0300985530484468,"A-总体方差":0.0223352875445233),
// ("A":0.957228042650968,"B":0.674682865617797,"A-总体方差":0.0605798191589568),
// ("A":0.73080830834806,"B":0.904764427104965,"A-总体方差":0.0611106539800822),
// ("A":0.236550874542445,"B":0.432319020619616,"A-总体方差":0.0607978820394406),
// ("A":0.479372498579323,"B":0.225869641872123,"A-总体方差":0.0547388465767192))
percentile(data, pct, rc, ml, assign, abnormal, fi_ll)
计算序列百分点PCT的值。
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array of real | 数组，存放实数的数组 |
pct |
real | 实数，表示百分点,从0开始,以1结束 |
rc |
integer | 行列选择:0求列第PCT个百分点的值；1求行第PCT个百分点的值；默认为0 |
ml |
integer | 整型，移动步长，取当前行向前ML个长度序列的百分点的值，为0时取整个序列（默认）。 |
assign |
integer|string|array | 下标或下标序列，对字段筛选，指定某些行列求百分点的值，为nil时为全部（默认）。 |
abnormal |
integer | 整型， |
fi_ll |
any | 数据data为空时的返回值。 |
返回：real
示例
范例1：序列百分点的值
// 返回数组Data的第3个百分点
data := array(5, 3, 6, 8, 9, 10, 4);
return percentile(data, 0.3);
// 输出：4.8
范例2：二维数组各列百分点的值
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：二维数组指定列指定步长的百分点的值
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)
已实现波动率(%)
| 参数 | 类型 | 说明 |
|---|---|---|
rsp_cycle |
any | 采样小周期 |
n |
any | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
返回：float
stdUp(rsp_cycle, n)
高频上行波动率(%)
| 参数 | 类型 | 说明 |
|---|---|---|
rsp_cycle |
any | 采样小周期 |
n |
any | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
返回：float
beta(rsp_cycle, n, cut_value)
S=|R|/(V^beta)
| 参数 | 类型 | 说明 |
|---|---|---|
rsp_cycle |
any | 采样小周期 |
n |
any | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
cut_value |
float | 划分截至比例 |
返回：float
lnv(rsp_cycle, n, cut_value)
S=|R|/ln(V)
| 参数 | 类型 | 说明 |
|---|---|---|
rsp_cycle |
any | 采样小周期 |
n |
any | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
cut_value |
float | 划分截至比例 |
返回：float
skewWBuy(rsp_cycle, k, n)
净委买变化率偏度
| 参数 | 类型 | 说明 |
|---|---|---|
rsp_cycle |
any | 采样小周期 |
k |
any | 前k档行情，默认为1 |
n |
any | 整型，当前时间向历史推移N个周期长度作为采样的时间区间(大区间)，与当前时间，周期相关。默认为 1，与市场周期对齐；N为0时，返回最后一个高频时刻 |
返回：float
sf_exppdf(values, lambda_value)
计算指数分布概率密度。
| 参数 | 类型 | 说明 |
|---|---|---|
values |
array | 随机变量序列；标量输入会返回 nil，生成代码时使用数组输入 |
lambda_value |
float | lambda 参数 |
返回：array
sf_expcdf(values, lambda_value)
计算指数分布累计分布值。
| 参数 | 类型 | 说明 |
|---|---|---|
values |
array | 随机变量序列；标量输入会返回 nil，生成代码时使用数组输入 |
lambda_value |
float | lambda 参数 |
返回：array
sf_mvtcdf(lower_bounds, upper_bounds, correlation_matrix, degrees_freedom)
计算多变量 t 分布累计分布值。
| 参数 | 类型 | 说明 |
|---|---|---|
lower_bounds |
array | 下界；传 nil 表示使用默认下界 |
upper_bounds |
array | 上界矩阵 |
correlation_matrix |
array | 相关系数矩阵 |
degrees_freedom |
float | 自由度 |
返回：array
sf_mvncdf(lower_bounds, upper_bounds, mean_values, correlation_matrix)
计算多变量正态分布累计分布值。
| 参数 | 类型 | 说明 |
|---|---|---|
lower_bounds |
array | 下界；传 nil 表示使用默认下界 |
upper_bounds |
array | 上界矩阵 |
mean_values |
array | 均值；传 nil 表示使用默认均值 |
correlation_matrix |
array | 相关系数矩阵 |
返回：array
Hypoth_SNUTest(values, mean_value, std_dev, tail, alpha)
执行单个正态总体均值 U 检验。
| 参数 | 类型 | 说明 |
|---|---|---|
values |
array | 样本数据 |
mean_value |
float | 原假设均值 |
std_dev |
float | 总体标准差 |
tail |
string | 检验方向；常用 "both"、"left"、"right" |
alpha |
float | 显著性水平 |
返回：array
Hypoth_SNDTest(values, variance_value, tail, alpha)
执行单个正态总体方差检验。
| 参数 | 类型 | 说明 |
|---|---|---|
values |
array | 样本数据 |
variance_value |
float | 原假设方差 |
tail |
string | 检验方向；常用 "both"、"left"、"right" |
alpha |
float | 显著性水平 |
返回：array
Anova_Twice(values, alpha, repeat_count)
执行双因素方差分析。
| 参数 | 类型 | 说明 |
|---|---|---|
values |
array | 观测值矩阵 |
alpha |
float | 显著性水平 |
repeat_count |
any | 每个因素水平组合的重复试验次数 |
返回：array
Hypoth_SignTest(values, probability, median_value, tail, alpha)
执行符号检验。
| 参数 | 类型 | 说明 |
|---|---|---|
values |
array | 样本数据 |
probability |
float | 原假设成功概率 |
median_value |
float | 原假设中位数 |
tail |
string | 检验方向；常用 "both"、"left"、"right" |
alpha |
float | 显著性水平 |
返回：array
correlpaired(a, b)
功能：计算 a 的每一列与 b 的每一列之间的相关系数矩阵，
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 一维数字数组, |
b |
array | 一维数字数组, |
返回：array
示例
范例01
a := rand(10);
b := rand(10);
return correlpaired(a, b); // array((0.17))
范例02
a := rand(10);
b := rand(10, 2);
return correlpaired(a, b); // array((-0.35,-0.19))
范例03
a := rand(10, 2);
b := rand(10, 4);
return correlpaired(a, b);
// 输出：
范例04
a := `array("A": rand(10));
b := `array("A": rand(10), "B": rand(10));
return correlpaired(a, b); // array((0.2,-0.08))
correlpaired_side(a, dir_type)
功能：计算 a 的每两列之间符合对应过滤条件的相关系数矩阵， 1) +-相关系数 ：将 a <0 的元素替换为0 ，b>0的元素替换为0,计算相关系数 2) 同向相关系数 ：将 a 与 b 非同向（乘积<0）的元素替换为0，计算相关系数 场景支持同 correlpaired 内部强制 a 转化为fmarray进行计算
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 一维数字数组, |
dir_type |
any | 用户自定义,方向类型 |
返回：array
sf_SinX(x, v)
正弦积分的定义为
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。自变量 |
v |
float | 实型变量，返回的结果 |
返回：any
sf_CosX(x, v)
余弦积分的定义为
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。自变量 |
v |
float | 实型变量，返回的结果 |
返回：any
sf_eX(x, v)
指数积分的定义为
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。自变量 |
v |
float | 实型变量，返回的结果 |
返回：any
sf_Gamma(x, v)
计算伽马(Gamma)函数的数值 伽马(Gamma)函数的定义为
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。要求X>=0 |
v |
float | 实型变量，返回的结果 |
返回：any
sf_Beta(x, y, v)
计算贝塔函数(Beta)的数值，贝塔函数(Beta)的定义为 或者：
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。要求X>=0 |
y |
float | 实型变量。要求Y>=0 |
v |
float | 实型变量，返回的结果 |
返回：any
sf_Error(x, v)
误差函数也称为概率函数，其定义为
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。要求X>=0 |
v |
float | 实型变量，返回的结果 |
返回：any
sf_Normal(x, a, d)
正态分布函数的定义为 其中： (1)a为随机变量的数学期望（平均值） (2)σ为随机变量的标准差
| 参数 | 类型 | 说明 |
|---|---|---|
x |
float | 实型变量。随机变量值 |
a |
float | 实型变量。数学期望值 |
d |
float | 实型变量。标准值 |
返回：any
sf_normalinv(data, m, s, v)
正态分布的分布逆函数，输入分布函数或者累计概率值，得到随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
m |
float | 正态分布参数，均值，实数类型 |
s |
float | 正态分布参数，标准差，实数类型 |
v |
array | 随机变量值，变参返回。 |
返回：any
sf_normalinv2(data, v)
标准正态分布的分布逆函数，输入分布函数或者累计概率值，得到随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
v |
array | 随机变量值，变参返回。 |
返回：any
sf_nbininv(y, r, p, x)
负二项分布的分布逆函数，输入累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
y |
array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
r |
any | 试验成功的次数,为大于0的整数 |
p |
float | 一次试验成功的概率,为0,1之间的实数 |
x |
array | 变参返回，该函数也支持直接返回，类型和y一样 |
返回：any
sf_tinv(data, n, v)
T分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
n |
any | 整数，自由度。 |
v |
array | 实数，随机变量值，变参返回。 |
返回：any
sf_finv(data, n, n1, v)
F分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
n |
any | 整数，分子自由度。 |
n1 |
any | 整数，分母自由度。 |
v |
array | 实数，随机变量值，变参返回。 |
返回：any
sf_x2inv(data, n, v)
卡方分布的分布逆函数，输入分布函数或者累计概率值，返回随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
data |
array | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
n |
any | 自由度。 |
v |
array | 随机变量值，变参返回。 |
返回：any
sf_gammainv(probability, alpha, v)
标准gamma分布的逆函数，输入分布函数或者累计概率值，返回随机变量值。功能等同于sf_gaminv(Probability, Alpha,1,v)。
| 参数 | 类型 | 说明 |
|---|---|---|
probability |
any | 分布函数或者累计概率值，可以使用实数，也可以是一个实数数组。 |
alpha |
any | Alpha分布参数。 |
v |
any | 随机变量值，变参返回 |
返回：any
sf_betainv(y, a, b, x)
贝塔分布的分布逆函数，输入分布函数值，输出随机变量值
| 参数 | 类型 | 说明 |
|---|---|---|
y |
array | :分布函数或者累计概率值，可以使用实数，也可以是一个实数数组 |
a |
float | beta分布参数1,实数,大于0 |
b |
float | beta分布参数2,实数,大于0 |
x |
array | 变参返回，类型和y一样 |
返回：any
mvtcdfqmc(a, b, rho, nu, options, funevals)
中间函数，采用蒙特卡洛计算多元t分布，估计概率P值以及误差
| 参数 | 类型 | 说明 |
|---|---|---|
a |
array | 数组，下限，可省略，默认为负无穷 |
b |
array | 数组，下限或实际需计算分布的样本值，不可省略 |
rho |
array | 数组，相关系数矩阵 |
nu |
float | 实数，自由度 |
options |
array | 数组，规划条件设置 |
funevals |
array | 线性回归的结果条件 |
返回：array
示例
范例01：
rho := array(
(1, 0.923912552224476, 0.035770327030089),
(0.923912552224476, 1, 0.084276570941762),
(0.035770327030089, 0.084276570941762, 1)
);
return mvtcdfqmc(array(0, 0, 0), rand(3), rho, 2, array());
sf_copulacdf(x, copula_type, rho, alpha, options)
估计多元函数分布值
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 数组，样本值为均匀分布需要在[0,1]区间内，至少2维 |
copula_type |
string | 字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维 |
rho |
array | 数组，相关系数矩阵，d*d |
alpha |
float | 实数，参数估计值，t分布时为自由度，二元阿基米德分布时为估值参数,默认1;；clayton:[0,∞)； frank:(-∞,∞)；gumbel:[1,∞) |
options |
array | 数组，估计规划条件，可为空 |
返回：array
sf_copulafit(x, copula_type, method, options)
估计多元分布相关系数矩阵
| 参数 | 类型 | 说明 |
|---|---|---|
x |
array | 数组，样本值为均匀分布需要在[0,1]区间内，至少2维 |
copula_type |
string | 字符串，分布函数类型:；椭圆族:gaussian、t，支持多维；阿基米德族:clayton、frank、gumbel，目前仅支持二维 |
method |
string | 字符串，极大似然估计方法(多元分布时有效)；ML —最大似然估计 （默认）；AML —调整的似然估计，性能上比MLE快，但不适用于中小样本量 |
options |
array | 数组，估计规划条件，可为空 |
返回：array
randCopula(copula_type, rho, v, n)
生成服从copula分布的随机数
| 参数 | 类型 | 说明 |
|---|---|---|
copula_type |
string | 字符串，分布函数类型:gaussian、t、clayton、frank、gumbel |
rho |
array | 数组，协方差矩阵，对阿基米德族(clayton、frank、gumbel分布)为空 |
v |
float | 实数，对t分布为自由度；对阿基米德族(clayton、frank、gumbel分布)为参数估计值，且其 |
n |
integer | 整数，产生随机数长度 |
返回：array
示例
范例01：gaussian分布
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分布
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调用相同)
alpha := 1;
n := 10;
return randCopula("clayton", nil, alpha, n);
Regress_VIFR2(x, w, constant)
vif分析增强
| 参数 | 类型 | 说明 |
|---|---|---|
x |
any | 表达式,自变量 |
w |
any | 表达式,权重 |
constant |
bool | object |
返回：array